diff --git a/01_weak_cues/adp_cues.py b/01_weak_cues/adp_cues.py
index 502b175..7b88c6c 100644
--- a/01_weak_cues/adp_cues.py
+++ b/01_weak_cues/adp_cues.py
@@ -6,6 +6,8 @@
 from utilities import *
 
 class ADPCues:
+    """Class for handling ADP cues"""
+
     def __init__(self, model_name, batch_size, size, model_dir='models',
                  devkit_dir=os.path.join(os.path.dirname(os.getcwd()), 'database', 'ADPdevkit', 'ADPRelease1')):
         self.model_dir = model_dir
@@ -60,6 +62,13 @@ def __init__(self, model_name, batch_size, size, model_dir='models',
         self.unions['func'] = np.zeros((len(self.classes['valid_func'])))
 
     def get_img_names(self, set_name):
+        """Read image names from file
+
+        Parameters
+        ----------
+        set_name : str
+            Name of the dataset
+        """
         img_names = []
         if set_name is None:
             img_names_path = os.path.join(self.devkit_dir, 'ImageSets', 'Segmentation', 'input_list.txt')
@@ -79,6 +88,8 @@ def get_img_names(self, set_name):
         return img_names
 
     def build_model(self):
+        """Build CNN model from saved files"""
+
         # Load architecture from json
         model_json_path = os.path.join(self.model_dir, self.model_name, self.model_name + '.json')
         json_file = open(model_json_path, 'r')
@@ -104,6 +115,20 @@ def build_model(self):
             self.thresholds = 0.5 * np.ones(self.model.output_shape[-1])
 
     def read_batch(self, batch_names):
+        """Read batch of images from filenames
+
+        Parameters
+        ----------
+        batch_names : list of str (size: B), B = batch size
+            List of filenames of images in batch
+
+        Returns
+        -------
+        img_batch_norm : numpy 4D array (size: B x H x W x 3), B = batch size
+            Normalized batch of input images
+        img_batch : numpy 4D array (size: B x H x W x 3), B = batch size
+            Unnormalized batch of input images
+        """
         cur_batch_size = len(batch_names)
         img_batch = np.empty((cur_batch_size, self.size, self.size, 3), dtype='uint8')
         for i in range(cur_batch_size):
@@ -116,6 +141,20 @@ def read_batch(self, batch_names):
         return img_batch_norm, img_batch
 
     def get_grad_cam_weights(self, dummy_image, should_normalize=True):
+        """Obtain Grad-CAM weights of the model
+
+        Parameters
+        ----------
+        dummy_image : numpy 4D array (size: 1 x H x W x 3)
+            A dummy image to calculate gradients
+        should_normalize : bool, optional
+            Whether to normalize the gradients
+
+        Returns
+        -------
+        weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+            The Grad-CAM weights of the model
+        """
         def find_final_layer(model):
             for iter_layer, layer in reversed(list(enumerate(model.layers))):
                 if type(layer) == type(layer) == keras.layers.convolutional.Conv2D:
@@ -146,6 +185,24 @@ def normalize(x):
 
     def grad_cam(self, weights, images, is_pass_threshold, orig_sz=[224, 224],
                  should_upsample=False):
+        """Generate Grad-CAM
+
+        Parameters
+        ----------
+        weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+            The Grad-CAM weights of the model
+        images : numpy 4D array (size: B x H x W x 3), where B = batch size
+            The batch of input images
+        is_pass_threshold : numpy 2D bool array (size: B x C), where B = batch size, C = number of classes
+            An array saving which classes pass the pre-defined thresholds for each image in the batch
+        orig_sz : list of int, optional
+            2D size of original images
+
+        Returns
+        -------
+        cams_thresh : numpy 4D array (size: B x H x W x C), B = batch size, C = number of classes
+            The thresholded Grad-CAMs
+        """
         conv_output = self.model.get_layer(self.final_layer).output  # activation_7
         conv_func = K.function([self.model.layers[0].input], [conv_output])
         conv_val = conv_func([images])
@@ -161,11 +218,44 @@ def grad_cam(self, weights, images, is_pass_threshold, orig_sz=[224, 224],
         return cams_thresh
 
     def split_by_httclass(self, H):
+        """Split classes in incoming variable by HTT class
+
+        Parameters
+        ----------
+        H : numpy <=2D array (size: B x C x ?), where B = batch size, C = number of classes
+            Variable to be split
+
+        Returns
+        -------
+        (H_morph) : numpy <=2D array (size: B x C_morph x ?), where B = batch size, C_morph = number of morphological classes
+            Split morphological classes in variable
+        (H_func) : numpy <=2D array (size: B x C_func x ?), where B = batch size, C_morph = number of functional classes
+            Split functional classes in variable
+        """
         morph_all_inds = [i for i, x in enumerate(self.classes['all']) if x in self.classes['morph']]
         func_all_inds = [i for i, x in enumerate(self.classes['all']) if x in self.classes['func']]
         return H[:, morph_all_inds], H[:, func_all_inds]
 
     def modify_by_htt(self, gradcam, images, classes, gradcam_adipose=None):
+        """Generates non-foreground class activations and appends to the foreground class activations
+
+        Parameters
+        ----------
+        gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+            The serialized Grad-CAM for the current batch
+        images : numpy 3D array (size: self.batch_size x H x W x 3)
+            The input images for the current batch
+        classes : list (size: C), where C = number of classes
+            The list of classes in gradcam
+        gradcam_adipose : numpy 4D array (size: self.num_imgs x C x H x W), where C = number of classes,
+                          or None, optional
+            Adipose class Grad-CAM (if segmenting functional types) or None (if not segmenting functional types)
+
+        Returns
+        -------
+        gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+            The modified Grad-CAM for the current batch, with non-foreground class activations appended
+        """
         if gradcam_adipose is None:
             htt_class = 'morph'
         else:
@@ -207,13 +297,23 @@ def modify_by_htt(self, gradcam, images, classes, gradcam_adipose=None):
         return gradcam
 
     def update_cues(self, gradcam, class_inds, htt_class, indices):
+        """Update the cues class object with current batch's Grad-CAM
+
+        Parameters
+        ----------
+        gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+            The serialized Grad-CAM for the current batch
+        class_inds : numpy 1D array (size: self.batch_size)
+            List of image indices in batch, as array
+        htt_class : str
+            The type of segmentation set to solve
+        indices : list of int (size: self.batch_size)
+            List of image indices in batch
+        """
         localization_onehot = np.zeros_like(gradcam)
-        background_mode = 'chan'  # {'chan', 'kolesnikov'}
-        # Obtain localization cues
-        if background_mode == 'chan':
-            # Non-other
-            localization = np.array(
-                gradcam > 0.2 * np.expand_dims(np.expand_dims(np.max(gradcam, axis=(2, 3)), axis=2), axis=3))
+        # Non-other
+        localization = np.array(gradcam > 0.2 *
+                                np.expand_dims(np.expand_dims(np.max(gradcam, axis=(2, 3)), axis=2), axis=3))
 
         # Solve overlap conflicts
         class_rank = np.argsort(-np.sum(np.sum(localization, axis=-1), axis=-1))  # from largest to smallest masks
@@ -232,6 +332,20 @@ def update_cues(self, gradcam, class_inds, htt_class, indices):
             self.cues[htt_class]['%d_cues' % x] = np.array(np.where(localization_onehot[i]))  # class is front
 
     def read_gt_batch(self, htt_class, batch_names):
+        """Read batch of GT segmentation images
+
+        Parameters
+        ----------
+        htt_class : str
+            The type of segmentation set to solve
+        batch_names : list of str (size: B), B = batch size
+            List of filenames of images in batch
+
+        Returns
+        -------
+        gt_batch : numpy 4D array (size: B x H x W x 3), where B = batch size
+            The batch of GT segmentation images
+        """
         cur_batch_size = len(batch_names)
         gt_batch = np.empty((cur_batch_size, self.size, self.size, 3), dtype='uint8')
         batch_names = [os.path.splitext(x)[0] + '.png' for x in batch_names]
diff --git a/01_weak_cues/dataset.py b/01_weak_cues/dataset.py
index 0b49918..5d9b225 100644
--- a/01_weak_cues/dataset.py
+++ b/01_weak_cues/dataset.py
@@ -3,6 +3,8 @@
 import pandas as pd
 
 class Dataset:
+    """Class for implementing dataset handling"""
+
     def __init__(self, data_type='ADP', size=321, batch_size=16):
         self.data_type = data_type
         self.size = size
@@ -11,13 +13,12 @@ def __init__(self, data_type='ADP', size=321, batch_size=16):
         #
         self.load_attributes()
         self.load_data()
-        # self.load_colours()
 
     def load_attributes(self):
+        """Load dataset attributes, especially ImageDataGenerator"""
+
         if self.data_type == 'ADP':
             self.devkit_dir = os.path.join(self.database_dir, 'ADPdevkit', 'ADPRelease1')
-            # self.sets = ['train', 'valid', 'test']
-            # self.is_evals = [False, True, True]
             self.sets = ['valid', 'test']
             self.is_evals = [True, True]
             self.class_names = ['E.M.S', 'E.M.U', 'E.M.O', 'E.T.S', 'E.T.U', 'E.T.O', 'E.P', 'C.D.I', 'C.D.R', 'C.L', 'H.E',
@@ -56,8 +57,6 @@ def normalize(x):
             self.devkit_dir = os.path.join(self.database_dir, 'VOCdevkit', 'VOC2012')
             self.sets = ['trainaug', 'val']
             self.is_evals = [False, True]
-            # self.sets = ['val']
-            # self.is_evals = [True]
             self.class_names = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
                            'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa',
                            'train',
@@ -97,6 +96,8 @@ def normalize(x):
                 rescale=1. / 255)
 
     def load_data(self):
+        """Load DataFrameIterator for dataset"""
+
         self.set_gens = {}
         if self.data_type == 'ADP':
             img_folder = 'PNGImages'
diff --git a/01_weak_cues/demo.py b/01_weak_cues/demo.py
index e9e1522..94d0555 100644
--- a/01_weak_cues/demo.py
+++ b/01_weak_cues/demo.py
@@ -19,6 +19,24 @@
 EVAL_CUES_ROOT = './cues_eval'
 
 def gen_cues(dataset, model_type, batch_size, set_name=None, run_train=True, is_verbose=True):
+    """Generate weak segmentation cues for VOC2012 and DeepGlobe datasets, with redirect for ADP
+
+    Parameters
+    ----------
+    dataset : str
+        The name of the dataset (i.e. 'ADP', 'VOC2012', 'DeepGlobe_train75', or 'DeepGlobe_train37.5')
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    batch_size : int
+        The batch size (>0)
+    set_name : str, optional
+        The name of the name of the evaluation set, if ADP (i.e. 'tuning' or 'segtest')
+    run_train : bool, optional
+        Whether to run on the training set
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
     assert(dataset in ['ADP', 'VOC2012', 'DeepGlobe_train75', 'DeepGlobe_train37.5'])
     assert(model_type in ['M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7', 'M7bg', 'VGG16', 'VGG16bg'])
     assert(os.path.exists(os.path.join(MODEL_ROOT, dataset + '_' + model_type)))
@@ -54,10 +72,11 @@ def gen_cues(dataset, model_type, batch_size, set_name=None, run_train=True, is_
     if is_verbose:
         print('\tLoading data')
     if dataset == 'ADP':
+        # Redirect to helper function if ADP
         if run_train:
-            gen_cues_adp(dataset, model_type, sess_id, batch_size, img_size, train_cues_dir, set_name, is_verbose)
+            gen_cues_adp(model_type, batch_size, img_size, train_cues_dir, set_name, is_verbose)
         else:
-            gen_cues_adp(dataset, model_type, sess_id, batch_size, img_size, eval_cues_dir, set_name, is_verbose)
+            gen_cues_adp(model_type, batch_size, img_size, eval_cues_dir, set_name, is_verbose)
         return
     ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)
     if run_train:
@@ -115,6 +134,8 @@ def load_model(model_dir, sess_id):
                 fgbg_sess[fgbg_mode] = sess_id.replace('fg', '') + 'bg'
         model[fgbg_mode], alpha[fgbg_mode], final_layer[fgbg_mode], thresholds[fgbg_mode] = \
             load_model(fgbg_dir[fgbg_mode], fgbg_sess[fgbg_mode])
+
+    # Process by batch
     n_batches = math.ceil(len(img_names) / batch_size)
     for iter_batch in range(n_batches):
         start_time = time.time()
@@ -131,11 +152,11 @@ def load_model(model_dir, sess_id):
             dataset_mean = [0, 0, 0]
             dataset_std = [255, 255, 255]
             ignore_ind = 6
+        # Read batches of normalized/unnormalized images
         img_batch_norm, img_batch = read_batch(gen_curr.directory, img_names[start_idx:end_idx + 1], cur_batch_sz,
                                                (img_size, img_size), img_mean=dataset_mean, img_std=dataset_std)
-
-        # Determine passing classes
         for fgbg_mode in fgbg_modes:
+            # Determine passing classes
             pred_scores = model[fgbg_mode].predict(img_batch_norm)
             keep_inds = np.arange(len(ds.class_names))
             if ignore_ind is not None:
@@ -145,22 +166,18 @@ def load_model(model_dir, sess_id):
             is_pass_threshold[fgbg_mode] = np.greater_equal(pred_scores, thresholds[fgbg_mode]) * \
                                            gen_curr.data[start_idx:end_idx+1, keep_inds]
 
-            # Generate CAM/Grad-CAM
+            # Generate Grad-CAM
             if fgbg_mode == 'fg':
                 fg_start_time = time.time()
-                mode = 'Grad-CAM'
-                if mode == 'Grad-CAM':
-                    H[fgbg_mode] = grad_cam(model[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],
-                                            final_layer[fgbg_mode], keep_inds, [img_size, img_size])
+                H[fgbg_mode] = grad_cam(model[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],
+                                        final_layer[fgbg_mode], keep_inds, [img_size, img_size])
                 elapsed_time = time.time() - fg_start_time
                 if is_verbose:
                     print('\t\tElapsed time (fg): %s seconds (%s seconds/image)' % (elapsed_time, elapsed_time / cur_batch_sz))
             elif fgbg_mode == 'bg':
                 bg_start_time = time.time()
-                mode = 'Grad-CAM'
-                if mode == 'Grad-CAM':
-                    H[fgbg_mode] = grad_cam(model[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],
-                                            final_layer[fgbg_mode], keep_inds, [img_size, img_size])
+                H[fgbg_mode] = grad_cam(model[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],
+                                        final_layer[fgbg_mode], keep_inds, [img_size, img_size])
                 elapsed_time = time.time() - bg_start_time
                 if is_verbose:
                     print('\t\tElapsed time (bg): %s seconds (%s seconds/image)' % (elapsed_time, elapsed_time / cur_batch_sz))
@@ -180,27 +197,45 @@ def load_model(model_dir, sess_id):
         elapsed_time = time.time() - start_time
         if is_verbose:
             print('\t\tElapsed time: %s seconds (%s seconds/image)' % (elapsed_time, elapsed_time / cur_batch_sz))
-    print('Saving localization cues')
+    if is_verbose:
+        print('Saving localization cues')
     if run_train:
+        # Training set localization cues (for further processing/training in 02, 03)
         pickle.dump(localization_cues, open(os.path.join(train_cues_dir, 'localization_cues.pickle'), 'wb'))
     else:
+        # Validation set localization cues (for evaluation only)
         pickle.dump(localization_cues, open(os.path.join(eval_cues_dir, 'localization_cues_val.pickle'), 'wb'))
 
-def gen_cues_adp(dataset, model_type, sess_id, batch_size, size, cues_dir, set_name, is_verbose):
-    ac = ADPCues(dataset + '_' + model_type, batch_size, size, model_dir=MODEL_ROOT)
+def gen_cues_adp(model_type, batch_size, size, cues_dir, set_name, is_verbose):
+    """Generate weak segmentation cues for ADP (helper function)
+
+    Parameters
+    ----------
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    batch_size : int
+        The batch size (>0)
+    size : int
+        The length of the resized input image
+    cues_dir : str
+        The directory to save the cues to
+    set_name : str
+        The name of the name of the evaluation set (i.e. 'tuning' or 'segtest')
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
+    ac = ADPCues('ADP_' + model_type, batch_size, size, model_dir=MODEL_ROOT)
     seed_size = 41
 
     # Load network and thresholds
-    out_dirs = {}
-    out_dirs['morph'] = os.path.join(cues_dir, 'morph')
-    if not os.path.exists(out_dirs['morph']):
-        os.makedirs(out_dirs['morph'])
-    out_dirs['func'] = os.path.join(cues_dir, 'func')
-    if not os.path.exists(out_dirs['func']):
-        os.makedirs(out_dirs['func'])
+    cues_dirs = {}
+    for htt_class in ['morph', 'func']:
+        cues_dirs[htt_class] = os.path.join(cues_dir, htt_class)
+        makedir_if_nexist([cues_dirs[htt_class]])
     ac.build_model()
 
-    # Load images
+    # Load Grad-CAM weights
     if not os.path.exists('data'):
         os.makedirs('data')
     if is_verbose:
@@ -253,23 +288,45 @@ def gen_cues_adp(dataset, model_type, sess_id, batch_size, size, cues_dir, set_n
                 seeds[htt_class] = ac.modify_by_htt(seeds[htt_class], img_batch, ac.classes['valid_' + htt_class],
                                                  gradcam_adipose=gradcam_adipose)
 
-            # Save localization cues
+            # Update localization cues
             ac.update_cues(seeds[htt_class], class_inds, htt_class, list(range(start_idx, end_idx + 1)))
         elapsed_time = time.time() - start_time
         if is_verbose:
             print('\t\tElapsed time: %s seconds (%s seconds/image)' % (elapsed_time, elapsed_time / cur_batch_sz))
+    # Save localization cues
     if is_verbose:
         print('\tSaving localization cues')
-    pickle.dump(ac.cues['morph'], open(os.path.join(out_dirs['morph'], 'localization_cues.pickle'), 'wb'))
-    pickle.dump(ac.cues['func'], open(os.path.join(out_dirs['func'], 'localization_cues.pickle'), 'wb'))
-
-def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, is_verbose=True):
+    pickle.dump(ac.cues['morph'], open(os.path.join(cues_dirs['morph'], 'localization_cues.pickle'), 'wb'))
+    pickle.dump(ac.cues['func'], open(os.path.join(cues_dirs['func'], 'localization_cues.pickle'), 'wb'))
+
+def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, should_saveimg=True, is_verbose=True):
+    """Evaluate weak segmentation cues for VOC2012 and DeepGlobe datasets, with redirect for ADP
+
+    Parameters
+    ----------
+    dataset : str
+        The name of the dataset (i.e. 'ADP', 'VOC2012', 'DeepGlobe_train75', or 'DeepGlobe_train37.5')
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    batch_size : int
+        The batch size (>0)
+    set_name : str, optional
+        The name of the name of the evaluation set, if ADP (i.e. 'tuning' or 'segtest')
+    run_train : bool, optional
+        Whether to run on the training set
+    should_saveimg : bool, optional
+        Whether to save debug images
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
     assert(dataset in ['ADP', 'VOC2012', 'DeepGlobe_train75', 'DeepGlobe_train37.5'])
     assert(model_type in ['M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7', 'M7bg', 'VGG16', 'VGG16bg'])
     assert(os.path.exists(os.path.join(MODEL_ROOT, dataset + '_' + model_type)))
     assert(batch_size > 0)
     assert(set_name in [None, 'tuning', 'segtest'])
     assert(type(run_train) is bool)
+    assert(type(should_saveimg) is bool)
     assert(type(is_verbose) is bool)
     if model_type in ['VGG16', 'VGG16bg']:
         img_size = 321
@@ -281,14 +338,14 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
         OVERLAY_R = 0.75
     elif 'DeepGlobe' in dataset:
         OVERLAY_R = 0.25
-
     if set_name is None:
         sess_id = dataset + '_' + model_type
     else:
         sess_id = dataset + '_' + set_name + '_' + model_type
     eval_cues_dir = os.path.join(EVAL_CUES_ROOT, sess_id)
-    out_dir = os.path.join(OUT_ROOT, sess_id)
-    makedir_if_nexist([out_dir])
+    if should_saveimg:
+        out_dir = os.path.join(OUT_ROOT, sess_id)
+        makedir_if_nexist([out_dir])
     if is_verbose:
         if set_name is None:
             print('Evaluate cues: dataset=' + dataset + ', model=' + model_type)
@@ -298,7 +355,8 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
     if is_verbose:
         print('\tLoading data')
     if dataset == 'ADP':
-        eval_cues_adp(dataset, model_type, sess_id, batch_size, img_size, set_name, is_verbose)
+        # Redirect to helper function if ADP
+        eval_cues_adp(model_type, sess_id, batch_size, img_size, set_name, should_saveimg, is_verbose)
         return
     makedir_if_nexist([eval_cues_dir])
     ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)
@@ -306,9 +364,10 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
     gen_eval = ds.set_gens[eval_set]
     colours = get_colours(dataset)
 
+    # Load localization cues from validation set for evaluation purposes
     cues_path = os.path.join(eval_cues_dir, 'localization_cues_val.pickle')
-
     if not os.path.exists(cues_path):
+        # Generate first if not already existing
         gen_cues(dataset, model_type, batch_size, run_train=False, is_verbose=is_verbose)
     localization_cues = pickle.load(open(cues_path, "rb"), encoding="iso-8859-1")
 
@@ -324,13 +383,17 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
         ignore_ind = 6
     intersects = np.zeros((len(colours)))
     unions = np.zeros((len(colours)))
+
+    # Evaluate one image at a time
     for iter_file, filename in enumerate(gen_eval.filenames):
         if is_verbose:
             print('\tImage #%d of %d' % (iter_file+1, len(gen_eval.filenames)))
         start_time = time.time()
         if dataset == 'VOC2012':
+            # Load GT segmentation
             gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))
             gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_RGB2BGR)[:, :, 0]
+            # Load predicted segmentation
             cues_i = localization_cues['%s_cues' % iter_file]
             cues_pred = np.zeros([seed_size, seed_size, len(colours)])
             cues_pred[cues_i[1], cues_i[2], cues_i[0]] = 1.0
@@ -338,14 +401,17 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
             pred_idx = cv2.resize(np.uint8(cues_pred_max), (gt_idx.shape[1], gt_idx.shape[0]),
                                   interpolation=cv2.INTER_NEAREST)
             pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))
+            # Evaluate predicted segmentation against GT
             for k in range(len(colours)):
                 intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))
                 unions[k] += np.sum((gt_idx == k) | (pred_idx == k))
                 pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \
                                 np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)
         elif 'DeepGlobe' in dataset:
+            # Load GT segmentation
             gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))
             gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_RGB2BGR)
+            # Load predicted segmentation
             cues_i = localization_cues['%s_cues' % iter_file]
             cues_pred = np.zeros([seed_size, seed_size, len(colours)])
             cues_pred[cues_i[1], cues_i[2], cues_i[0]] = 1.0
@@ -354,6 +420,7 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
             pred_idx = cv2.resize(np.uint8(cues_pred_max), (gt_curr.shape[1], gt_curr.shape[0]),
                                   interpolation=cv2.INTER_NEAREST)
             pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))
+            # Evaluate predicted segmentation against GT
             gt_r = gt_curr[:, :, 0]
             gt_g = gt_curr[:, :, 1]
             gt_b = gt_curr[:, :, 2]
@@ -364,36 +431,58 @@ def eval_cues(dataset, model_type, batch_size, set_name=None, run_train=False, i
                 unions[k] += np.sum(gt_mask | pred_mask)
                 pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \
                                 np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)
-        orig_filepath = os.path.join(gen_eval.directory, filename)
-        orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)
-        if 'DeepGlobe' in dataset:
-            orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))
-            pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),
-                                      interpolation=cv2.INTER_NEAREST)
-        imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)
-        imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),
-                     (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)
+        # Save debugging images to file
+        if should_saveimg:
+            orig_filepath = os.path.join(gen_eval.directory, filename)
+            orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)
+            # Downsample to save space if DeepGlobe
+            if 'DeepGlobe' in dataset:
+                orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))
+                pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),
+                                          interpolation=cv2.INTER_NEAREST)
+            imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)
+            imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),
+                         (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)
         if is_verbose:
             print('\t\tElapsed time (s): %s' % (time.time() - start_time))
+    # Calculate mIoU and save to .xlsx metrics file
     mIoU = np.mean(intersects / (unions + 1e-7))
     df = pd.DataFrame({'Class': seg_class_names + ['Mean'], 'IoU': list(intersects / (unions + 1e-7)) + [mIoU]},
                       columns=['Class', 'IoU'])
     xlsx_path = os.path.join(eval_cues_dir, 'metrics_' + sess_id + '_' + eval_set + '.xlsx')
     df.to_excel(xlsx_path)
 
-def eval_cues_adp(dataset, model_type, sess_id, batch_size, size, set_name, is_verbose):
-    ac = ADPCues(dataset + '_' + model_type, batch_size, size, model_dir=MODEL_ROOT)
+def eval_cues_adp(model_type, sess_id, batch_size, size, set_name, should_saveimg, is_verbose):
+    """Evaluate weak segmentation cues for ADP (helper function)
+
+    Parameters
+    ----------
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    sess_id : str
+        The identifying string for the current session
+    batch_size : int
+        The batch size (>0)
+    size : int
+        The length of the resized input image
+    set_name : str, optional
+        The name of the name of the evaluation set, if ADP (i.e. 'tuning' or 'segtest')
+    should_saveimg : bool, optional
+        Whether to save debug images
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
+    ac = ADPCues('ADP_' + model_type, batch_size, size, model_dir=MODEL_ROOT)
     seed_size = 41
     OVERLAY_R = 0.75
 
     # Load network and thresholds
-    out_dirs = {}
-    out_dirs['morph'] = os.path.join(OUT_ROOT, sess_id, 'morph')
-    if not os.path.exists(out_dirs['morph']):
-        os.makedirs(out_dirs['morph'])
-    out_dirs['func'] = os.path.join(OUT_ROOT, sess_id, 'func')
-    if not os.path.exists(out_dirs['func']):
-        os.makedirs(out_dirs['func'])
+    if should_saveimg:
+        out_dirs = {}
+        for htt_class in ['morph', 'func']:
+            out_dirs[htt_class] = os.path.join(OUT_ROOT, sess_id, htt_class)
+            makedir_if_nexist([out_dirs[htt_class]])
     ac.build_model()
 
     # Load images
@@ -447,19 +536,23 @@ def eval_cues_adp(dataset, model_type, sess_id, batch_size, size, set_name, is_v
                 gradcam_adipose = seeds['morph'][:, adipose_inds]
                 seeds[htt_class] = ac.modify_by_htt(seeds[htt_class], img_batch, ac.classes['valid_' + htt_class],
                                                  gradcam_adipose=gradcam_adipose)
-
-            # Evaluate
+            # Update cues
             ac.update_cues(seeds[htt_class], class_inds, htt_class, list(range(start_idx, end_idx + 1)))
-            gt_batch = ac.read_gt_batch(htt_class, img_names[start_idx:end_idx + 1])
 
+            # Load GT segmentation images
+            gt_batch = ac.read_gt_batch(htt_class, img_names[start_idx:end_idx + 1])
+            # Process images one at a time
             for j in range(cur_batch_sz):
-                pred_segmask = np.zeros((size, size, 3))
+                # Separate GT segmentation images into R, G, B channels
                 gt_r = gt_batch[j, :, :, 0]
                 gt_g = gt_batch[j, :, :, 1]
                 gt_b = gt_batch[j, :, :, 2]
+                # Load predicted segmentations
                 cues_i = ac.cues[htt_class]['%s_cues' % (start_idx + j)]
                 cues = np.zeros((seed_size, seed_size, len(ac.colours[htt_class])))
                 cues[cues_i[1], cues_i[2], cues_i[0]] = 1.0
+                pred_segmask = np.zeros((size, size, 3))
+                # Evaluate predicted segmentations
                 for k, gt_colour in enumerate(ac.colours[htt_class]):
                     gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])
                     pred_mask = cv2.resize(cues[:, :, k], (size, size), interpolation=cv2.INTER_NEAREST) == 1.0
@@ -467,14 +560,16 @@ def eval_cues_adp(dataset, model_type, sess_id, batch_size, size, set_name, is_v
                                     np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)
                     ac.intersects[htt_class][k] += np.sum(gt_mask & pred_mask)
                     ac.unions[htt_class][k] += np.sum(gt_mask | pred_mask)
-                imgio.imsave(os.path.join(out_dirs[htt_class], os.path.splitext(img_names[start_idx+j])[0] + '.png'), pred_segmask / 256.0)
-                imgio.imsave(os.path.join(out_dirs[htt_class], os.path.splitext(img_names[start_idx+j])[0] + '_overlay.png'),
-                             (1-OVERLAY_R) * img_batch[j] / 256.0 + OVERLAY_R * pred_segmask / 256.0)
-
+                # Save debugging images to file
+                if should_saveimg:
+                    imgio.imsave(os.path.join(out_dirs[htt_class], os.path.splitext(img_names[start_idx+j])[0] + '.png'),
+                                 pred_segmask / 256.0)
+                    imgio.imsave(os.path.join(out_dirs[htt_class], os.path.splitext(img_names[start_idx+j])[0] + '_overlay.png'),
+                                 (1-OVERLAY_R) * img_batch[j] / 256.0 + OVERLAY_R * pred_segmask / 256.0)
         elapsed_time = time.time() - start_time
         if is_verbose:
             print('\t\tElapsed time: %s seconds (%s seconds/image)' % (elapsed_time, elapsed_time / cur_batch_sz))
-
+    # Calculate IoU, mIoU metrics
     iou = {}
     miou = {}
     for htt_class in ['morph', 'func']:
@@ -484,8 +579,8 @@ def eval_cues_adp(dataset, model_type, sess_id, batch_size, size, set_name, is_v
             print('\tmIoU (%s): %s' % (htt_class, miou[htt_class]))
 
         eval_dir = os.path.join(EVAL_CUES_ROOT, sess_id)
-        if not os.path.exists(eval_dir):
-            os.makedirs(eval_dir)
+        makedir_if_nexist([eval_dir])
+        # Save to .xlsx metrics file
         df = pd.DataFrame({'Class': ac.classes['valid_' + htt_class] + ['Mean'], 'IoU': list(iou[htt_class]) + [miou[htt_class]]},
                           columns=['Class', 'IoU'])
         xlsx_path = os.path.join(eval_dir, 'metrics_ADP-' + htt_class + '_' + set_name + '_' + model_type + '.xlsx')
@@ -494,24 +589,24 @@ def eval_cues_adp(dataset, model_type, sess_id, batch_size, size, set_name, is_v
 if __name__ == "__main__":
     # ADP
     gen_cues(dataset='ADP', model_type='VGG16', batch_size=16, is_verbose=True)
-    eval_cues(dataset='ADP', model_type='VGG16', batch_size=16, set_name='tuning', is_verbose=True)
-    eval_cues(dataset='ADP', model_type='VGG16', batch_size=16, set_name='segtest', is_verbose=True)
-    gen_cues(dataset='ADP', model_type='X1.7', batch_size=16, is_verbose=True)
-    eval_cues(dataset='ADP', model_type='X1.7', batch_size=16, set_name='tuning', is_verbose=True)
-    eval_cues(dataset='ADP', model_type='X1.7', batch_size=16, set_name='segtest', is_verbose=True)
+    eval_cues(dataset='ADP', model_type='VGG16', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
+    eval_cues(dataset='ADP', model_type='VGG16', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
+    gen_cues(dataset='ADP', model_type='X1.7', batch_size=16, should_saveimg=True, is_verbose=True)
+    eval_cues(dataset='ADP', model_type='X1.7', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
+    eval_cues(dataset='ADP', model_type='X1.7', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
 
     # PASCAL VOC 2012
-    gen_cues(dataset='VOC2012', model_type='VGG16', batch_size=8, is_verbose=True) # validated
-    eval_cues(dataset='VOC2012', model_type='VGG16', batch_size=8, is_verbose=True) # validated
+    gen_cues(dataset='VOC2012', model_type='VGG16', batch_size=8, is_verbose=True)
+    eval_cues(dataset='VOC2012', model_type='VGG16', batch_size=8, should_saveimg=True, is_verbose=True)
     gen_cues(dataset='VOC2012', model_type='M7', batch_size=8, is_verbose=True)
-    eval_cues(dataset='VOC2012', model_type='M7', batch_size=8, is_verbose=True)
+    eval_cues(dataset='VOC2012', model_type='M7', batch_size=8, should_saveimg=True, is_verbose=True)
 
     # DeepGlobe
     gen_cues(dataset='DeepGlobe_train75', model_type='VGG16', batch_size=8, is_verbose=True)
-    eval_cues(dataset='DeepGlobe_train75', model_type='VGG16', batch_size=8, is_verbose=True)
+    eval_cues(dataset='DeepGlobe_train75', model_type='VGG16', batch_size=8, should_saveimg=True,  is_verbose=True)
     gen_cues(dataset='DeepGlobe_train75', model_type='M7', batch_size=8, is_verbose=True)
-    eval_cues(dataset='DeepGlobe_train75', model_type='M7', batch_size=8, is_verbose=True)
+    eval_cues(dataset='DeepGlobe_train75', model_type='M7', batch_size=8, should_saveimg=True, is_verbose=True)
     gen_cues(dataset='DeepGlobe_train37.5', model_type='VGG16', batch_size=8, is_verbose=True)
-    eval_cues(dataset='DeepGlobe_train37.5', model_type='VGG16', batch_size=8, is_verbose=True)
+    eval_cues(dataset='DeepGlobe_train37.5', model_type='VGG16', batch_size=8, should_saveimg=True, is_verbose=True)
     gen_cues(dataset='DeepGlobe_train37.5', model_type='M7', batch_size=8, is_verbose=True)
-    eval_cues(dataset='DeepGlobe_train37.5', model_type='M7', batch_size=8, is_verbose=True)
\ No newline at end of file
+    eval_cues(dataset='DeepGlobe_train37.5', model_type='M7', batch_size=8, should_saveimg=True, is_verbose=True)
\ No newline at end of file
diff --git a/01_weak_cues/utilities.py b/01_weak_cues/utilities.py
index c600bd7..5a63f09 100644
--- a/01_weak_cues/utilities.py
+++ b/01_weak_cues/utilities.py
@@ -6,11 +6,32 @@
 import scipy
 
 def makedir_if_nexist(dir_list):
+    """Create empty directory if it does not already exist
+
+    Parameters
+    ----------
+    dir_list : list of str
+        List of directories to create
+    """
     for cur_dir in dir_list:
         if not os.path.exists(cur_dir):
             os.makedirs(cur_dir)
 
 def resize_stack(stack, size):
+    """Resize stack to specified 2D size
+
+    Parameters
+    ----------
+    stack : numpy 4D array (size: B x C x H x W), where B = batch size, C = number of classes
+        The stack to be resized
+    size : list of int
+        The 2D size to be resized to
+
+    Returns
+    -------
+    stack : numpy 4D array (size: B x C x H x W), where B = batch size, C = number of classes
+        The resized stack
+    """
     old_stack = stack[:]
     stack = np.zeros((stack.shape[0], stack.shape[1], size[0], size[1]))
     for i in range(stack.shape[0]):
@@ -18,29 +39,43 @@ def resize_stack(stack, size):
             stack[i, j] = cv2.resize(old_stack[i, j], (size[0], size[1]))
     return stack
 
-def show_values(pc, fmt="%.2f", **kw):
-    '''
-    Heatmap with text in each cell with matplotlib's pyplot
-    Source: http://stackoverflow.com/a/25074150/395857
-    By HYRY
-    '''
-    pc.update_scalarmappable()
-    ax = pc.axes
-    for p, color, value in zip(pc.get_paths(), pc.get_facecolors(), pc.get_array()):
-        x, y = p.vertices[:-2, :].mean(0)
-        if np.all(color[:3] > 0.5):
-            color = (0.0, 0.0, 0.0)
-        else:
-            color = (1.0, 1.0, 1.0)
-        ax.text(x, y, fmt % value, ha="center", va="center", color=color, **kw)
-
 def find_final_layer(model):
+    """Find final layer's name in model
+
+    Parameters
+    ----------
+    model : keras.engine.sequential.Sequential object
+        The input model
+
+    Returns
+    -------
+    (final_layer) : str
+        The name of the final layer
+    """
     for iter_layer, layer in reversed(list(enumerate(model.layers))):
         if type(layer) == type(layer) == keras.layers.convolutional.Conv2D:
             return model.layers[iter_layer+1].name
     raise Exception('Could not find the final layer in provided HistoNet')
 
 def get_grad_cam_weights(input_model, final_layer, dummy_image, should_normalize=True):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    input_model : keras.engine.sequential.Sequential object
+        The input model
+    final_layer : str
+        The name of the final layer
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     conv_output = input_model.get_layer(final_layer).output # activation_7
     num_classes = input_model.output_shape[1]
     num_feats = int(conv_output.shape[-1])
@@ -50,6 +85,7 @@ def normalize(x):
         return x / (K.sqrt(K.mean(K.square(x))) + 1e-5)
 
     for iter_class in range(input_model.output_shape[1]):
+        # Obtain the gradients from the classifier wrt. the final convolutional layer
         y_c = input_model.layers[-2].output[0, iter_class]
         if should_normalize:
             grad = normalize(K.gradients(y_c, conv_output)[0])
@@ -58,27 +94,79 @@ def normalize(x):
         grad_func = K.function([input_model.layers[0].input, K.learning_phase()], [conv_output, grad])
         conv_val, grad_val = grad_func([dummy_image, 0])
         conv_val, grad_val = conv_val[0], grad_val[0]
+        # Apply 2D mean
         weights[:, iter_class] = np.mean(grad_val, axis=(0, 1))
     return weights
 
 def grad_cam(input_model, weights, images, is_pass_threshold, final_layer, keep_inds, orig_sz=[224, 224], should_upsample=False):
+    """Generate Grad-CAM
+
+    Parameters
+    ----------
+    input_model : keras.engine.sequential.Sequential object
+        The input model
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    images : numpy 4D array (size: B x H x W x 3), where B = batch size
+        The batch of input images
+    is_pass_threshold : numpy 2D bool array (size: B x C), where B = batch size, C = number of classes
+        An array saving which classes pass the pre-defined thresholds for each image in the batch
+    final_layer : str
+        The name of the final layer
+    keep_inds : numpy 1D array
+        Array of class indices to keep
+    orig_sz : list of int, optional
+        2D size of original images
+    should_upsample : bool, optional
+        Whether to upsample the generated Grad-CAM activation maps to original input size
+
+    Returns
+    -------
+    cams_thresh : numpy 4D array (size: B x H x W x C), B = batch size, C = number of classes
+        The thresholded Grad-CAMs
+    """
+    # Obtain gradients and apply weights
     conv_output = input_model.get_layer(final_layer).output  # activation_7
     conv_func = K.function([input_model.layers[0].input], [conv_output])
     conv_val = conv_func([images])
     conv_val = conv_val[0]
     cams = np.maximum(np.einsum('ijkl,lm->ijkm', conv_val, weights), 0)
     cams = cams[:, :, :, keep_inds]
+    # Upsample to original size if requested
     if should_upsample:
         old_cams = cams[:]
         cams = np.zeros((old_cams.shape[0], orig_sz[0], orig_sz[1], old_cams.shape[-1]))
         for i in range(cams.shape[0]):
             for j in range(cams.shape[-1]):
                 cams[i, :, :, j] = cv2.resize(cams[i, :, :, j], (orig_sz[0], orig_sz[1]))
+    # Eliminate classes not passing threshold
     cams_thresh = cams * np.expand_dims(np.expand_dims(is_pass_threshold, axis=1), axis=2)
     return cams_thresh
 
 def read_batch(img_dir, batch_names, batch_sz, sz, img_mean=[193.09203, 193.09203, 193.02903],
                img_std=[56.450138, 56.450138, 56.450138]):
+    """Read a batch of images
+
+    Parameters
+    ----------
+    img_dir : str
+        Directory holding the input images
+    batch_names : list of str
+        Filenames of the input images
+    batch_sz : int
+        The batch size
+    img_mean : list of float (size: 3), optional
+        Three-channel image set mean
+    img_std : list of float (size: 3), optional
+        Three-channel image set standard deviation
+
+    Returns
+    -------
+    img_batch_norm : numpy 4D array (size: B x H x W x 3), B = batch size
+        Normalized batch of input images
+    img_batch : numpy 4D array (size: B x H x W x 3), B = batch size
+        Unnormalized batch of input images
+    """
     img_mean = np.float64(img_mean)
     img_std = np.float64(img_std)
     img_batch = np.empty((batch_sz, sz[0], sz[1], 3), dtype='uint8')
@@ -93,6 +181,26 @@ def read_batch(img_dir, batch_names, batch_sz, sz, img_mean=[193.09203, 193.0920
     return img_batch_norm, img_batch
 
 def get_fgbg_cues(cues, H_fg, H_bg, class_inds, indices):
+    """Get weak foreground/background cues
+
+    Parameters
+    ----------
+    cues : dict
+        Weak foreground/background cues, as a dictionary of passing classes and cue locations
+    H_fg : numpy 4D array (size: B x C x H x W), B = batch size, C = number of classes
+        Activation maps of foreground network
+    H_bg : numpy 4D array (size: B x C x H x W), B = batch size, C = number of classes
+        Activation maps of background network
+    class_inds : numpy 1D array (size: B), B = batch size
+        Image indices in current batch
+    indices : list (size: B), B = batch size
+        Image indices in current batch, as a list
+
+    Returns
+    -------
+    cues: dict
+        Weak foreground/background cues, as a dictionary of passing classes and cue locations
+    """
     n_seg_classes = H_fg.shape[1] + 1
     localization_onehot = np.zeros((H_fg.shape[0], n_seg_classes, H_fg.shape[2], H_fg.shape[3]), dtype='int64')
     localization = np.zeros_like(localization_onehot)
@@ -120,10 +228,28 @@ def get_fgbg_cues(cues, H_fg, H_bg, class_inds, indices):
     # Save true one-hot encoded values
     for i,x in enumerate(indices):
         cues['%d_labels' % x] = class_inds[i]
-        cues['%d_cues' % x] = np.array(np.where(localization_onehot[i])) # class is front
+        cues['%d_cues' % x] = np.array(np.where(localization_onehot[i]))
     return cues
 
 def get_fg_cues(cues, H_fg, class_inds, indices):
+    """Get weak foreground cues
+
+    Parameters
+    ----------
+    cues : dict
+        Weak foreground/background cues, as a dictionary of passing classes and cue locations
+    H_fg : numpy 4D array (size: B x C x H x W), B = batch size, C = number of classes
+        Activation maps of foreground network
+    class_inds : numpy 1D array (size: B), B = batch size
+        Image indices in current batch
+    indices : list (size: B), B = batch size
+        Image indices in current batch, as a list
+
+    Returns
+    -------
+    cues: dict
+        Weak foreground/background cues, as a dictionary of passing classes and cue locations
+    """
     n_seg_classes = H_fg.shape[1]
     localization_onehot = np.zeros((H_fg.shape[0], n_seg_classes, H_fg.shape[2], H_fg.shape[3]), dtype='int64')
     localization = np.zeros_like(localization_onehot)
@@ -144,10 +270,22 @@ def get_fg_cues(cues, H_fg, class_inds, indices):
     # Save true one-hot encoded values
     for i,x in enumerate(indices):
         cues['%d_labels' % x] = class_inds[i]
-        cues['%d_cues' % x] = np.array(np.where(localization_onehot[i])) # class is front
+        cues['%d_cues' % x] = np.array(np.where(localization_onehot[i]))
     return cues
 
 def get_colours(segset):
+    """Obtain class segmentation colours, given the dataset
+
+    Parameters
+    ----------
+    segset : str
+        The dataset to segment, (i.e. 'ADP-morph', 'ADP-func', 'VOC2012', 'DeepGlobe_train75', or 'DeepGlobe_train37.5')
+
+    Returns
+    -------
+    (colours) : numpy 1D array of 3-tuples
+        Class segmentation colours for the given dataset
+    """
     if segset == 'ADP-morph':
         return np.array([(255, 255, 255), (0, 0, 128), (0, 128, 0), (255, 165, 0), (255, 192, 203),
                          (255, 0, 0), (173, 20, 87), (176, 141, 105), (3, 155, 229),
diff --git a/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-adp-checkpoint.ipynb b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-adp-checkpoint.ipynb
new file mode 100644
index 0000000..2fd6442
--- /dev/null
+++ b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-adp-checkpoint.ipynb
@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-deepglobe-checkpoint.ipynb b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-deepglobe-checkpoint.ipynb
new file mode 100644
index 0000000..6b3af00
--- /dev/null
+++ b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-deepglobe-checkpoint.ipynb
@@ -0,0 +1,438 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02_hsn_v1_lean-deepglobe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import skimage.io as imgio\n",
+    "import pandas as pd\n",
+    "import numpy.matlib\n",
+    "\n",
+    "from adp_cues import ADPCues\n",
+    "from utilities import *\n",
+    "from dataset import Dataset\n",
+    "\n",
+    "MODEL_CNN_ROOT = '../database/models_cnn'\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predict: dataset=DeepGlobe_train75, model=VGG16\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataset = 'DeepGlobe_train75'\n",
+    "model_type = 'VGG16'\n",
+    "batch_size = 16\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    size = 321\n",
+    "else:\n",
+    "    size = 224\n",
+    "should_saveimg = False\n",
+    "is_verbose = True\n",
+    "\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    img_size = 321\n",
+    "else:\n",
+    "    img_size = 224\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "model_dir = os.path.join(MODEL_CNN_ROOT, sess_id)\n",
+    "\n",
+    "if is_verbose:\n",
+    "    print('Predict: dataset=' + dataset + ', model=' + model_type)\n",
+    "\n",
+    "database_dir = os.path.join(os.path.dirname(os.getcwd()), 'database')\n",
+    "if dataset == 'VOC2012':\n",
+    "    devkit_dir = os.path.join(database_dir, 'VOCdevkit', 'VOC2012')\n",
+    "    fgbg_modes = ['fg', 'bg']\n",
+    "    OVERLAY_R = 0.75\n",
+    "elif 'DeepGlobe' in dataset:\n",
+    "    devkit_dir = os.path.join(database_dir, 'DGdevkit')\n",
+    "    fgbg_modes = ['fg']\n",
+    "    OVERLAY_R = 0.25\n",
+    "img_dir = os.path.join(devkit_dir, 'JPEGImages')\n",
+    "gt_dir = os.path.join(devkit_dir, 'SegmentationClassAug')\n",
+    "\n",
+    "out_dir = os.path.join('./out', sess_id)\n",
+    "if not os.path.exists(out_dir):\n",
+    "    os.makedirs(out_dir)\n",
+    "eval_dir = os.path.join('./eval', sess_id)\n",
+    "if not os.path.exists(eval_dir):\n",
+    "    os.makedirs(eval_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load network and data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n",
+      "Found 603 validated image filenames.\n",
+      "Found 200 validated image filenames.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load network and thresholds\n",
+    "mdl = {}\n",
+    "thresholds = {}\n",
+    "alpha = {}\n",
+    "final_layer = {}\n",
+    "for fgbg_mode in fgbg_modes:\n",
+    "    mdl[fgbg_mode] = build_model(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = load_thresholds(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = np.maximum(np.minimum(thresholds[fgbg_mode], 0), 1 / 3)\n",
+    "    alpha[fgbg_mode], final_layer[fgbg_mode] = get_grad_cam_weights(mdl[fgbg_mode],\n",
+    "                                                                    np.zeros((1, img_size, img_size, 3)))\n",
+    "\n",
+    "# Load data and classes\n",
+    "ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)\n",
+    "class_names, seg_class_names = load_classes(dataset)\n",
+    "colours = get_colours(dataset)\n",
+    "if 'DeepGlobe' in dataset:\n",
+    "    colours = colours[:-1]\n",
+    "gen_curr = ds.set_gens[ds.sets[ds.is_evals.index(True)]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate segmentations for single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tBatch #1 of 1\n",
+      "\t\tImage read time: 1.64935 seconds (0.10308 seconds / image)\n",
+      "\t\tGenerating patch confidence scores time: 23.69109 seconds (1.48069 seconds / image)\n",
+      "\t\tGenerating Grad-CAM time: 23.16229 seconds (1.44764 seconds / image)\n",
+      "\t\tFg/Bg modifications time: 0.00000 seconds (0.00000 seconds / image)\n",
+      "\t\tCRF time: 4.82387 seconds (0.30149 seconds / image)\n",
+      "\t\tElapsed time: 53.32660 seconds (3.33291 seconds / image)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Process images in batches\n",
+    "intersects = np.zeros((len(colours)))\n",
+    "unions = np.zeros((len(colours)))\n",
+    "confusion_matrix = np.zeros((len(colours), len(colours)))\n",
+    "gt_count = np.zeros((len(colours)))\n",
+    "n_batches = 1\n",
+    "for iter_batch in range(n_batches):\n",
+    "    batch_start_time = time.time()\n",
+    "    if is_verbose:\n",
+    "        print('\\tBatch #%d of %d' % (iter_batch + 1, n_batches))\n",
+    "    start_idx = iter_batch * batch_size\n",
+    "    end_idx = min(start_idx + batch_size - 1, len(gen_curr.filenames) - 1)\n",
+    "    cur_batch_sz = end_idx - start_idx + 1\n",
+    "\n",
+    "    # Image reading\n",
+    "    start_time = time.time()\n",
+    "    img_batch_norm, img_batch = read_batch(gen_curr.directory, gen_curr.filenames[start_idx:end_idx + 1],\n",
+    "                                           cur_batch_sz, (img_size, img_size), dataset)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                      (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate patch confidence scores\n",
+    "    start_time = time.time()\n",
+    "    predicted_scores = {}\n",
+    "    is_pass_threshold = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        predicted_scores[fgbg_mode] = mdl[fgbg_mode].predict(img_batch_norm)\n",
+    "        is_pass_threshold[fgbg_mode] = np.greater_equal(predicted_scores[fgbg_mode], thresholds[fgbg_mode])\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %\n",
+    "                                            (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate Grad-CAM\n",
+    "    start_time = time.time()\n",
+    "    H = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        H[fgbg_mode] = grad_cam(mdl[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],\n",
+    "                                final_layer[fgbg_mode], predicted_scores[fgbg_mode], orig_sz=[img_size, img_size],\n",
+    "                                should_upsample=True)\n",
+    "        H[fgbg_mode] = np.transpose(H[fgbg_mode], (0, 3, 1, 2))\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Modify fg Grad-CAM with bg activation\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        Y_gradcam = np.zeros((cur_batch_sz, len(seg_class_names), img_size, img_size))\n",
+    "        mode = 'mult'\n",
+    "        if mode == 'mult':\n",
+    "            X_bg = np.sum(H['bg'], axis=1)\n",
+    "            Y_gradcam[:, 0] = 0.15 * scipy.special.expit(np.max(X_bg) - X_bg)\n",
+    "        Y_gradcam[:, 1:] = H['fg']\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        Y_gradcam = H['fg'][:, :-1, :, :]\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                     (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # FC-CRF\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        dcrf_config = np.array([3 / 4, 3, 80 / 4, 13, 10, 10])  # test (since 2448 / 500 = 4.896 ~= 4)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        dcrf_config = np.array([3, 3, 80, 13, 10, 10])  # test\n",
+    "    Y_crf = dcrf_process(Y_gradcam, img_batch, dcrf_config)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                 (time.time() - start_time) / cur_batch_sz))\n",
+    "    elapsed_time = time.time() - batch_start_time\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))\n",
+    "\n",
+    "    if dataset == 'VOC2012':\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_idx.shape[1], gt_idx.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k in range(len(colours)):\n",
+    "                intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))\n",
+    "                unions[k] += np.sum((gt_idx == k) | (pred_idx == k))\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_idx == k], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_idx == k)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 +\n",
+    "                             OVERLAY_R * pred_segmask / 256.0)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)\n",
+    "            gt_r = gt_curr[:, :, 0]\n",
+    "            gt_g = gt_curr[:, :, 1]\n",
+    "            gt_b = gt_curr[:, :, 2]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_curr.shape[1], gt_curr.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k, gt_colour in enumerate(colours):\n",
+    "                gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])\n",
+    "                pred_mask = pred_idx == k\n",
+    "                intersects[k] += np.sum(gt_mask & pred_mask)\n",
+    "                unions[k] += np.sum(gt_mask | pred_mask)\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_mask], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_mask, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_mask)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))\n",
+    "                pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),\n",
+    "                                          interpolation=cv2.INTER_NEAREST)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show sample segmentations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_filepath = os.path.join(gen_curr.directory, gen_curr.filenames[0])\n",
+    "I = cv2.cvtColor(cv2.imread(img_filepath), cv2.COLOR_BGR2RGB)\n",
+    "gt_filepath = os.path.join(gt_dir, gen_curr.filenames[0].replace('.jpg', '.png'))\n",
+    "G = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth\\n segmentation')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth\\n segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load predicted segmentation\n",
+    "pred_idx = cv2.resize(np.uint8(Y_crf[0]), (G.shape[1], G.shape[0]), interpolation=cv2.INTER_NEAREST)\n",
+    "Y = np.zeros((G.shape[0], G.shape[1], 3))\n",
+    "# Evaluate predicted segmentation\n",
+    "for k, gt_colour in enumerate(colours):\n",
+    "    pred_mask = pred_idx == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "# Obtain overlay\n",
+    "Y_overlay = ((1 - OVERLAY_R) * I / 255.0 + OVERLAY_R * Y / 255.0) * 255"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Overlaid\\n Segmentation')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Predicted\\n Segmentation')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y_overlay.astype('uint8'))\n",
+    "plt.title('Overlaid\\n Segmentation')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-voc2012-checkpoint.ipynb b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-voc2012-checkpoint.ipynb
new file mode 100644
index 0000000..c5f32e2
--- /dev/null
+++ b/02_hsn_v1_lean/.ipynb_checkpoints/02_hsn_v1_lean-voc2012-checkpoint.ipynb
@@ -0,0 +1,437 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02_hsn_v1_lean-voc2012"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import skimage.io as imgio\n",
+    "import pandas as pd\n",
+    "import numpy.matlib\n",
+    "\n",
+    "from adp_cues import ADPCues\n",
+    "from utilities import *\n",
+    "from dataset import Dataset\n",
+    "\n",
+    "MODEL_CNN_ROOT = '../database/models_cnn'\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predict: dataset=VOC2012, model=VGG16\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataset = 'VOC2012'\n",
+    "model_type = 'VGG16'\n",
+    "batch_size = 16\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    size = 321\n",
+    "else:\n",
+    "    size = 224\n",
+    "should_saveimg = False\n",
+    "is_verbose = True\n",
+    "\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    img_size = 321\n",
+    "else:\n",
+    "    img_size = 224\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "model_dir = os.path.join(MODEL_CNN_ROOT, sess_id)\n",
+    "\n",
+    "if is_verbose:\n",
+    "    print('Predict: dataset=' + dataset + ', model=' + model_type)\n",
+    "\n",
+    "database_dir = os.path.join(os.path.dirname(os.getcwd()), 'database')\n",
+    "if dataset == 'VOC2012':\n",
+    "    devkit_dir = os.path.join(database_dir, 'VOCdevkit', 'VOC2012')\n",
+    "    fgbg_modes = ['fg', 'bg']\n",
+    "    OVERLAY_R = 0.75\n",
+    "elif 'DeepGlobe' in dataset:\n",
+    "    devkit_dir = os.path.join(database_dir, 'DGdevkit')\n",
+    "    fgbg_modes = ['fg']\n",
+    "    OVERLAY_R = 0.25\n",
+    "img_dir = os.path.join(devkit_dir, 'JPEGImages')\n",
+    "gt_dir = os.path.join(devkit_dir, 'SegmentationClassAug')\n",
+    "\n",
+    "out_dir = os.path.join('./out', sess_id)\n",
+    "if not os.path.exists(out_dir):\n",
+    "    os.makedirs(out_dir)\n",
+    "eval_dir = os.path.join('./eval', sess_id)\n",
+    "if not os.path.exists(eval_dir):\n",
+    "    os.makedirs(eval_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load network and data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n",
+      "Found 1449 validated image filenames.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load network and thresholds\n",
+    "mdl = {}\n",
+    "thresholds = {}\n",
+    "alpha = {}\n",
+    "final_layer = {}\n",
+    "for fgbg_mode in fgbg_modes:\n",
+    "    mdl[fgbg_mode] = build_model(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = load_thresholds(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = np.maximum(np.minimum(thresholds[fgbg_mode], 0), 1 / 3)\n",
+    "    alpha[fgbg_mode], final_layer[fgbg_mode] = get_grad_cam_weights(mdl[fgbg_mode],\n",
+    "                                                                    np.zeros((1, img_size, img_size, 3)))\n",
+    "\n",
+    "# Load data and classes\n",
+    "ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)\n",
+    "class_names, seg_class_names = load_classes(dataset)\n",
+    "colours = get_colours(dataset)\n",
+    "if 'DeepGlobe' in dataset:\n",
+    "    colours = colours[:-1]\n",
+    "gen_curr = ds.set_gens[ds.sets[ds.is_evals.index(True)]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate segmentations for single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tBatch #1 of 1\n",
+      "\t\tImage read time: 0.09221 seconds (0.00576 seconds / image)\n",
+      "\t\tGenerating patch confidence scores time: 49.51458 seconds (3.09466 seconds / image)\n",
+      "\t\tGenerating Grad-CAM time: 51.20006 seconds (3.20000 seconds / image)\n",
+      "\t\tFg/Bg modifications time: 0.37858 seconds (0.02366 seconds / image)\n",
+      "\t\tCRF time: 5.80165 seconds (0.36260 seconds / image)\n",
+      "\t\tElapsed time: 106.98709 seconds (6.68669 seconds / image)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Process images in batches\n",
+    "intersects = np.zeros((len(colours)))\n",
+    "unions = np.zeros((len(colours)))\n",
+    "confusion_matrix = np.zeros((len(colours), len(colours)))\n",
+    "gt_count = np.zeros((len(colours)))\n",
+    "n_batches = 1\n",
+    "for iter_batch in range(n_batches):\n",
+    "    batch_start_time = time.time()\n",
+    "    if is_verbose:\n",
+    "        print('\\tBatch #%d of %d' % (iter_batch + 1, n_batches))\n",
+    "    start_idx = iter_batch * batch_size\n",
+    "    end_idx = min(start_idx + batch_size - 1, len(gen_curr.filenames) - 1)\n",
+    "    cur_batch_sz = end_idx - start_idx + 1\n",
+    "\n",
+    "    # Image reading\n",
+    "    start_time = time.time()\n",
+    "    img_batch_norm, img_batch = read_batch(gen_curr.directory, gen_curr.filenames[start_idx:end_idx + 1],\n",
+    "                                           cur_batch_sz, (img_size, img_size), dataset)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                      (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate patch confidence scores\n",
+    "    start_time = time.time()\n",
+    "    predicted_scores = {}\n",
+    "    is_pass_threshold = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        predicted_scores[fgbg_mode] = mdl[fgbg_mode].predict(img_batch_norm)\n",
+    "        is_pass_threshold[fgbg_mode] = np.greater_equal(predicted_scores[fgbg_mode], thresholds[fgbg_mode])\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %\n",
+    "                                            (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate Grad-CAM\n",
+    "    start_time = time.time()\n",
+    "    H = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        H[fgbg_mode] = grad_cam(mdl[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],\n",
+    "                                final_layer[fgbg_mode], predicted_scores[fgbg_mode], orig_sz=[img_size, img_size],\n",
+    "                                should_upsample=True)\n",
+    "        H[fgbg_mode] = np.transpose(H[fgbg_mode], (0, 3, 1, 2))\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Modify fg Grad-CAM with bg activation\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        Y_gradcam = np.zeros((cur_batch_sz, len(seg_class_names), img_size, img_size))\n",
+    "        mode = 'mult'\n",
+    "        if mode == 'mult':\n",
+    "            X_bg = np.sum(H['bg'], axis=1)\n",
+    "            Y_gradcam[:, 0] = 0.15 * scipy.special.expit(np.max(X_bg) - X_bg)\n",
+    "        Y_gradcam[:, 1:] = H['fg']\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        Y_gradcam = H['fg'][:, :-1, :, :]\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                     (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # FC-CRF\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        dcrf_config = np.array([3 / 4, 3, 80 / 4, 13, 10, 10])  # test (since 2448 / 500 = 4.896 ~= 4)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        dcrf_config = np.array([3, 3, 80, 13, 10, 10])  # test\n",
+    "    Y_crf = dcrf_process(Y_gradcam, img_batch, dcrf_config)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                 (time.time() - start_time) / cur_batch_sz))\n",
+    "    elapsed_time = time.time() - batch_start_time\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))\n",
+    "\n",
+    "    if dataset == 'VOC2012':\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_idx.shape[1], gt_idx.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k in range(len(colours)):\n",
+    "                intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))\n",
+    "                unions[k] += np.sum((gt_idx == k) | (pred_idx == k))\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_idx == k], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_idx == k)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 +\n",
+    "                             OVERLAY_R * pred_segmask / 256.0)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)\n",
+    "            gt_r = gt_curr[:, :, 0]\n",
+    "            gt_g = gt_curr[:, :, 1]\n",
+    "            gt_b = gt_curr[:, :, 2]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_curr.shape[1], gt_curr.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k, gt_colour in enumerate(colours):\n",
+    "                gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])\n",
+    "                pred_mask = pred_idx == k\n",
+    "                intersects[k] += np.sum(gt_mask & pred_mask)\n",
+    "                unions[k] += np.sum(gt_mask | pred_mask)\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_mask], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_mask, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_mask)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))\n",
+    "                pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),\n",
+    "                                          interpolation=cv2.INTER_NEAREST)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show sample segmentations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_filepath = os.path.join(gen_curr.directory, gen_curr.filenames[0])\n",
+    "I = cv2.cvtColor(cv2.imread(img_filepath), cv2.COLOR_BGR2RGB)\n",
+    "gt_filepath = os.path.join(gt_dir, gen_curr.filenames[0].replace('.jpg', '.png'))\n",
+    "gt_idx = np.expand_dims(cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0], axis=0)\n",
+    "G = maxconf_class_as_colour(gt_idx, colours, gt_idx.shape[1:3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth\\n segmentation')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G[0].astype('uint8'))\n",
+    "plt.title('Ground truth\\n segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load predicted segmentation\n",
+    "pred_idx = cv2.resize(np.uint8(Y_crf[0]), (gt_idx.shape[2], gt_idx.shape[1]), interpolation=cv2.INTER_NEAREST)\n",
+    "Y = np.zeros((gt_idx.shape[1], gt_idx.shape[2], 3))\n",
+    "# Evaluate predicted segmentation\n",
+    "for k in range(len(colours)):\n",
+    "    Y += np.expand_dims(pred_idx == k, axis=2) * np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "# Obtain overlay\n",
+    "Y_overlay = (1 - OVERLAY_R) * I.astype('uint8') + OVERLAY_R * Y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Overlaid\\n Segmentation')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Predicted\\n Segmentation')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y_overlay.astype('uint8'))\n",
+    "plt.title('Overlaid\\n Segmentation')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/02_hsn_v1_lean-adp.ipynb b/02_hsn_v1_lean/02_hsn_v1_lean-adp.ipynb
new file mode 100644
index 0000000..62e8c3d
--- /dev/null
+++ b/02_hsn_v1_lean/02_hsn_v1_lean-adp.ipynb
@@ -0,0 +1,470 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02_hsn_v1_lean-adp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import skimage.io as imgio\n",
+    "import pandas as pd\n",
+    "import numpy.matlib\n",
+    "\n",
+    "from adp_cues import ADPCues\n",
+    "from utilities import *\n",
+    "from dataset import Dataset\n",
+    "\n",
+    "MODEL_CNN_ROOT = '../database/models_cnn'\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataset = 'ADP'\n",
+    "model_type = 'VGG16'\n",
+    "batch_size = 16\n",
+    "set_name = 'segtest'\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    size = 321\n",
+    "else:\n",
+    "    size = 224\n",
+    "should_saveimg = False\n",
+    "is_verbose = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load Grad-CAM weights"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
+      "\tGetting Grad-CAM weights for given network\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n"
+     ]
+    }
+   ],
+   "source": [
+    "ac = ADPCues(sess_id, batch_size, size, model_dir=MODEL_CNN_ROOT)\n",
+    "OVERLAY_R = 0.75\n",
+    "\n",
+    "# Load network and thresholds\n",
+    "ac.build_model()\n",
+    "\n",
+    "# Load images\n",
+    "if is_verbose:\n",
+    "    print('\\tGetting Grad-CAM weights for given network')\n",
+    "alpha = ac.get_grad_cam_weights(np.zeros((1, size, size, 3)))\n",
+    "\n",
+    "# Read in image names\n",
+    "img_names = ac.get_img_names(set_name)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate segmentations for single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tBatch #1 of 1\n",
+      "\t\tImage read time: 0.94042 seconds (0.05878 seconds / image)\n",
+      "\t\tGenerating patch confidence scores time: 13.47637 seconds (0.84227 seconds / image)\n",
+      "\t\tGenerating Grad-CAM time: 16.81824 seconds (1.05114 seconds / image)\n",
+      "\t\t\tInter-HTT adjustments time [morph]: 2.00019 seconds (0.12501 seconds / image)\n",
+      "\t\t\tCRF time [morph]: 5.01705 seconds (0.31357 seconds / image)\n",
+      "\t\t\tInter-HTT adjustments time [func]: 0.50176 seconds (0.03136 seconds / image)\n",
+      "\t\t\tCRF time [func]: 7.35867 seconds (0.45992 seconds / image)\n",
+      "\tElapsed time: 67.52247 seconds (4.22015 seconds / image)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Process images in batches\n",
+    "confusion_matrix = {}\n",
+    "gt_count = {}\n",
+    "out_dirs = {}\n",
+    "for htt_class in ['morph', 'func']:\n",
+    "    confusion_matrix[htt_class] = np.zeros((len(ac.classes['valid_' + htt_class]), len(ac.classes['valid_' + htt_class])))\n",
+    "    gt_count[htt_class] = np.zeros((len(ac.classes['valid_' + htt_class])))\n",
+    "    out_dirs[htt_class] = os.path.join('out', 'ADP-' + htt_class + '_' + set_name + '_' + model_type)\n",
+    "    if not os.path.exists(out_dirs[htt_class]):\n",
+    "        os.makedirs(out_dirs[htt_class])\n",
+    "n_batches = 1 # len(img_names) // batch_size + 1\n",
+    "for iter_batch in range(n_batches):\n",
+    "    batch_start_time = time.time()\n",
+    "    print('\\tBatch #%d of %d' % (iter_batch + 1, n_batches))\n",
+    "    start_idx = iter_batch * batch_size\n",
+    "    end_idx = min(start_idx + batch_size - 1, len(img_names) - 1)\n",
+    "    cur_batch_sz = end_idx - start_idx + 1\n",
+    "\n",
+    "    # Image reading\n",
+    "    start_time = time.time()\n",
+    "    img_batch_norm, img_batch = ac.read_batch(img_names[start_idx:end_idx + 1])\n",
+    "    print('\\t\\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (\n",
+    "    time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate patch confidence scores\n",
+    "    start_time = time.time()\n",
+    "    predicted_scores = ac.model.predict(img_batch_norm)\n",
+    "    is_pass_threshold = np.greater_equal(predicted_scores, ac.thresholds)\n",
+    "    print('\\t\\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' % (\n",
+    "    time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate Grad-CAM\n",
+    "    start_time = time.time()\n",
+    "    H = grad_cam(ac.model, alpha, img_batch_norm, is_pass_threshold, ac.final_layer, predicted_scores,\n",
+    "                 orig_sz=[size, size], should_upsample=True)\n",
+    "    H = np.transpose(H, (0, 3, 1, 2))\n",
+    "    # Split Grad-CAM into {morph, func}\n",
+    "    H_split = {}\n",
+    "    H_split['morph'], H_split['func'] = split_by_httclass(H, ac.classes['all'], ac.classes['morph'], ac.classes['func'])\n",
+    "    is_pass = {}\n",
+    "    is_pass['morph'], is_pass['func'] = split_by_httclass(is_pass_threshold, ac.classes['all'], ac.classes['morph'], ac.classes['func'])\n",
+    "    print('\\t\\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (\n",
+    "    time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Modify Grad-CAM for each HTT type separately\n",
+    "    Y_gradcam = {}\n",
+    "    Y_csgc = {}\n",
+    "    Y_crf = {}\n",
+    "    for htt_class in ['morph', 'func']:\n",
+    "        Y_gradcam[htt_class] = np.zeros((cur_batch_sz, len(ac.classes['valid_' + htt_class]), size, size))\n",
+    "        Y_gradcam[htt_class][:, ac.classinds[htt_class + '2valid']] = H[:, ac.classinds['all2' + htt_class]]\n",
+    "\n",
+    "        # Inter-HTT Adjustments\n",
+    "        start_time = time.time()\n",
+    "        if htt_class == 'morph':\n",
+    "            Y_gradcam[htt_class] = modify_by_htt(Y_gradcam[htt_class], img_batch, ac.classes['valid_' + htt_class])\n",
+    "        elif htt_class == 'func':\n",
+    "            adipose_inds = [i for i, x in enumerate(ac.classes['morph']) if x in ['A.W', 'A.B', 'A.M']]\n",
+    "            gradcam_adipose = Y_gradcam['morph'][:, adipose_inds]\n",
+    "            Y_gradcam[htt_class] = modify_by_htt(Y_gradcam[htt_class], img_batch, ac.classes['valid_' + htt_class],\n",
+    "                                                 gradcam_adipose=gradcam_adipose)\n",
+    "        Y_csgc[htt_class] = get_cs_gradcam(Y_gradcam[htt_class], ac.classes['valid_' + htt_class], htt_class)\n",
+    "        print('\\t\\t\\tInter-HTT adjustments time [%s]: %0.5f seconds (%0.5f seconds / image)' % (htt_class,\n",
+    "        time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "        # FC-CRF\n",
+    "        start_time = time.time()\n",
+    "        dcrf_config = np.load(os.path.join(MODEL_WSSS_ROOT, htt_class + '_optimal_pcc.npy'))[0]\n",
+    "        Y_crf[htt_class] = dcrf_process(Y_csgc[htt_class], img_batch, dcrf_config)\n",
+    "        print('\\t\\t\\tCRF time [%s]: %0.5f seconds (%0.5f seconds / image)' % (htt_class,\n",
+    "        time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "        # Update evaluation performance\n",
+    "        _, gt_batch = read_batch(os.path.join(ac.gt_root, 'ADP-' + htt_class), img_names[start_idx:end_idx + 1], cur_batch_sz,\n",
+    "                                 [1088, 1088], 'ADP')\n",
+    "        for iter_img in range(cur_batch_sz):\n",
+    "            pred_idx = cv2.resize(Y_crf[htt_class][iter_img], dsize=(1088, 1088), interpolation=cv2.INTER_NEAREST)\n",
+    "            gt_r = gt_batch[iter_img][:, :, 0]\n",
+    "            gt_g = gt_batch[iter_img][:, :, 1]\n",
+    "            gt_b = gt_batch[iter_img][:, :, 2]\n",
+    "            pred_segmask = np.zeros((1088, 1088, 3))\n",
+    "            for k, gt_colour in enumerate(ac.colours[htt_class]):\n",
+    "                gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])\n",
+    "                pred_mask = pred_idx == k\n",
+    "                confusion_matrix[htt_class][k, :] += np.bincount(pred_idx[gt_mask],\n",
+    "                                                                 minlength=len(ac.classes['valid_' + htt_class]))\n",
+    "                ac.intersects[htt_class][k] += np.sum(gt_mask & pred_mask)\n",
+    "                ac.unions[htt_class][k] += np.sum(gt_mask | pred_mask)\n",
+    "                pred_segmask += np.expand_dims(pred_mask, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(ac.colours[htt_class][k], axis=0), axis=0)\n",
+    "                gt_count[htt_class][k] += np.sum(gt_mask)\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(ac.img_dir, img_names[start_idx + iter_img])\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)\n",
+    "                pred_segmask_small = cv2.resize(pred_segmask, (orig_img.shape[0], orig_img.shape[1]),\n",
+    "                                                interpolation=cv2.INTER_NEAREST)\n",
+    "                imgio.imsave(\n",
+    "                    os.path.join(out_dirs[htt_class], img_names[start_idx + iter_img].replace('.png', '') + '.png'),\n",
+    "                    pred_segmask_small / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dirs[htt_class],\n",
+    "                                          img_names[start_idx + iter_img].replace('.png', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 +\n",
+    "                             OVERLAY_R * pred_segmask_small / 256.0)\n",
+    "    elapsed_time = time.time() - batch_start_time\n",
+    "    print('\\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show sample segmentations"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Morphological Types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "I = cv2.cvtColor(cv2.imread(os.path.join(ac.img_dir, img_names[0])), cv2.COLOR_RGB2BGR)\n",
+    "_, G = read_batch(os.path.join(ac.gt_root, 'ADP-morph'), [img_names[0]], 1, [1088, 1088], 'ADP')\n",
+    "Y_gradcam_morph = maxconf_class_as_colour(np.argmax(Y_gradcam['morph'], axis=1), ac.colours['morph'], [321, 321])[0]\n",
+    "Y_csgc_morph = maxconf_class_as_colour(np.argmax(Y_csgc['morph'], axis=1), ac.colours['morph'], [321, 321])[0]\n",
+    "Y_crf_morph = maxconf_class_as_colour(Y_crf['morph'], ac.colours['morph'], [321, 321])[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Morphological\\n ground truth')"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G[0].astype('uint8'))\n",
+    "plt.title('Morphological\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF')"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(131)\n",
+    "plt.imshow(Y_gradcam_morph.astype('uint8'))\n",
+    "plt.title('Adjusted\\n Grad-CAM')\n",
+    "plt.subplot(132)\n",
+    "plt.imshow(Y_csgc_morph.astype('uint8'))\n",
+    "plt.title('Post-Class\\n Specific')\n",
+    "plt.subplot(133)\n",
+    "plt.imshow(Y_crf_morph.astype('uint8'))\n",
+    "plt.title('Post-CRF')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Functional Types"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "_, G = read_batch(os.path.join(ac.gt_root, 'ADP-func'), [img_names[0]], 1, [1088, 1088], 'ADP')\n",
+    "Y_gradcam_func = maxconf_class_as_colour(np.argmax(Y_gradcam['func'], axis=1), ac.colours['func'], [321, 321])[0]\n",
+    "Y_csgc_func = maxconf_class_as_colour(np.argmax(Y_csgc['func'], axis=1), ac.colours['func'], [321, 321])[0]\n",
+    "Y_crf_func = maxconf_class_as_colour(Y_crf['func'], ac.colours['func'], [321, 321])[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Functional\\n ground truth')"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G[0].astype('uint8'))\n",
+    "plt.title('Functional\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF')"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(131)\n",
+    "plt.imshow(Y_gradcam_func.astype('uint8'))\n",
+    "plt.title('Adjusted\\n Grad-CAM')\n",
+    "plt.subplot(132)\n",
+    "plt.imshow(Y_csgc_func.astype('uint8'))\n",
+    "plt.title('Post-Class\\n Specific')\n",
+    "plt.subplot(133)\n",
+    "plt.imshow(Y_crf_func.astype('uint8'))\n",
+    "plt.title('Post-CRF')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/02_hsn_v1_lean-deepglobe.ipynb b/02_hsn_v1_lean/02_hsn_v1_lean-deepglobe.ipynb
new file mode 100644
index 0000000..6b3af00
--- /dev/null
+++ b/02_hsn_v1_lean/02_hsn_v1_lean-deepglobe.ipynb
@@ -0,0 +1,438 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02_hsn_v1_lean-deepglobe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import skimage.io as imgio\n",
+    "import pandas as pd\n",
+    "import numpy.matlib\n",
+    "\n",
+    "from adp_cues import ADPCues\n",
+    "from utilities import *\n",
+    "from dataset import Dataset\n",
+    "\n",
+    "MODEL_CNN_ROOT = '../database/models_cnn'\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predict: dataset=DeepGlobe_train75, model=VGG16\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataset = 'DeepGlobe_train75'\n",
+    "model_type = 'VGG16'\n",
+    "batch_size = 16\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    size = 321\n",
+    "else:\n",
+    "    size = 224\n",
+    "should_saveimg = False\n",
+    "is_verbose = True\n",
+    "\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    img_size = 321\n",
+    "else:\n",
+    "    img_size = 224\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "model_dir = os.path.join(MODEL_CNN_ROOT, sess_id)\n",
+    "\n",
+    "if is_verbose:\n",
+    "    print('Predict: dataset=' + dataset + ', model=' + model_type)\n",
+    "\n",
+    "database_dir = os.path.join(os.path.dirname(os.getcwd()), 'database')\n",
+    "if dataset == 'VOC2012':\n",
+    "    devkit_dir = os.path.join(database_dir, 'VOCdevkit', 'VOC2012')\n",
+    "    fgbg_modes = ['fg', 'bg']\n",
+    "    OVERLAY_R = 0.75\n",
+    "elif 'DeepGlobe' in dataset:\n",
+    "    devkit_dir = os.path.join(database_dir, 'DGdevkit')\n",
+    "    fgbg_modes = ['fg']\n",
+    "    OVERLAY_R = 0.25\n",
+    "img_dir = os.path.join(devkit_dir, 'JPEGImages')\n",
+    "gt_dir = os.path.join(devkit_dir, 'SegmentationClassAug')\n",
+    "\n",
+    "out_dir = os.path.join('./out', sess_id)\n",
+    "if not os.path.exists(out_dir):\n",
+    "    os.makedirs(out_dir)\n",
+    "eval_dir = os.path.join('./eval', sess_id)\n",
+    "if not os.path.exists(eval_dir):\n",
+    "    os.makedirs(eval_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load network and data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n",
+      "Found 603 validated image filenames.\n",
+      "Found 200 validated image filenames.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load network and thresholds\n",
+    "mdl = {}\n",
+    "thresholds = {}\n",
+    "alpha = {}\n",
+    "final_layer = {}\n",
+    "for fgbg_mode in fgbg_modes:\n",
+    "    mdl[fgbg_mode] = build_model(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = load_thresholds(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = np.maximum(np.minimum(thresholds[fgbg_mode], 0), 1 / 3)\n",
+    "    alpha[fgbg_mode], final_layer[fgbg_mode] = get_grad_cam_weights(mdl[fgbg_mode],\n",
+    "                                                                    np.zeros((1, img_size, img_size, 3)))\n",
+    "\n",
+    "# Load data and classes\n",
+    "ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)\n",
+    "class_names, seg_class_names = load_classes(dataset)\n",
+    "colours = get_colours(dataset)\n",
+    "if 'DeepGlobe' in dataset:\n",
+    "    colours = colours[:-1]\n",
+    "gen_curr = ds.set_gens[ds.sets[ds.is_evals.index(True)]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate segmentations for single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tBatch #1 of 1\n",
+      "\t\tImage read time: 1.64935 seconds (0.10308 seconds / image)\n",
+      "\t\tGenerating patch confidence scores time: 23.69109 seconds (1.48069 seconds / image)\n",
+      "\t\tGenerating Grad-CAM time: 23.16229 seconds (1.44764 seconds / image)\n",
+      "\t\tFg/Bg modifications time: 0.00000 seconds (0.00000 seconds / image)\n",
+      "\t\tCRF time: 4.82387 seconds (0.30149 seconds / image)\n",
+      "\t\tElapsed time: 53.32660 seconds (3.33291 seconds / image)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Process images in batches\n",
+    "intersects = np.zeros((len(colours)))\n",
+    "unions = np.zeros((len(colours)))\n",
+    "confusion_matrix = np.zeros((len(colours), len(colours)))\n",
+    "gt_count = np.zeros((len(colours)))\n",
+    "n_batches = 1\n",
+    "for iter_batch in range(n_batches):\n",
+    "    batch_start_time = time.time()\n",
+    "    if is_verbose:\n",
+    "        print('\\tBatch #%d of %d' % (iter_batch + 1, n_batches))\n",
+    "    start_idx = iter_batch * batch_size\n",
+    "    end_idx = min(start_idx + batch_size - 1, len(gen_curr.filenames) - 1)\n",
+    "    cur_batch_sz = end_idx - start_idx + 1\n",
+    "\n",
+    "    # Image reading\n",
+    "    start_time = time.time()\n",
+    "    img_batch_norm, img_batch = read_batch(gen_curr.directory, gen_curr.filenames[start_idx:end_idx + 1],\n",
+    "                                           cur_batch_sz, (img_size, img_size), dataset)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                      (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate patch confidence scores\n",
+    "    start_time = time.time()\n",
+    "    predicted_scores = {}\n",
+    "    is_pass_threshold = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        predicted_scores[fgbg_mode] = mdl[fgbg_mode].predict(img_batch_norm)\n",
+    "        is_pass_threshold[fgbg_mode] = np.greater_equal(predicted_scores[fgbg_mode], thresholds[fgbg_mode])\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %\n",
+    "                                            (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate Grad-CAM\n",
+    "    start_time = time.time()\n",
+    "    H = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        H[fgbg_mode] = grad_cam(mdl[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],\n",
+    "                                final_layer[fgbg_mode], predicted_scores[fgbg_mode], orig_sz=[img_size, img_size],\n",
+    "                                should_upsample=True)\n",
+    "        H[fgbg_mode] = np.transpose(H[fgbg_mode], (0, 3, 1, 2))\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Modify fg Grad-CAM with bg activation\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        Y_gradcam = np.zeros((cur_batch_sz, len(seg_class_names), img_size, img_size))\n",
+    "        mode = 'mult'\n",
+    "        if mode == 'mult':\n",
+    "            X_bg = np.sum(H['bg'], axis=1)\n",
+    "            Y_gradcam[:, 0] = 0.15 * scipy.special.expit(np.max(X_bg) - X_bg)\n",
+    "        Y_gradcam[:, 1:] = H['fg']\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        Y_gradcam = H['fg'][:, :-1, :, :]\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                     (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # FC-CRF\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        dcrf_config = np.array([3 / 4, 3, 80 / 4, 13, 10, 10])  # test (since 2448 / 500 = 4.896 ~= 4)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        dcrf_config = np.array([3, 3, 80, 13, 10, 10])  # test\n",
+    "    Y_crf = dcrf_process(Y_gradcam, img_batch, dcrf_config)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                 (time.time() - start_time) / cur_batch_sz))\n",
+    "    elapsed_time = time.time() - batch_start_time\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))\n",
+    "\n",
+    "    if dataset == 'VOC2012':\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_idx.shape[1], gt_idx.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k in range(len(colours)):\n",
+    "                intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))\n",
+    "                unions[k] += np.sum((gt_idx == k) | (pred_idx == k))\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_idx == k], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_idx == k)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 +\n",
+    "                             OVERLAY_R * pred_segmask / 256.0)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)\n",
+    "            gt_r = gt_curr[:, :, 0]\n",
+    "            gt_g = gt_curr[:, :, 1]\n",
+    "            gt_b = gt_curr[:, :, 2]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_curr.shape[1], gt_curr.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k, gt_colour in enumerate(colours):\n",
+    "                gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])\n",
+    "                pred_mask = pred_idx == k\n",
+    "                intersects[k] += np.sum(gt_mask & pred_mask)\n",
+    "                unions[k] += np.sum(gt_mask | pred_mask)\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_mask], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_mask, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_mask)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))\n",
+    "                pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),\n",
+    "                                          interpolation=cv2.INTER_NEAREST)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show sample segmentations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_filepath = os.path.join(gen_curr.directory, gen_curr.filenames[0])\n",
+    "I = cv2.cvtColor(cv2.imread(img_filepath), cv2.COLOR_BGR2RGB)\n",
+    "gt_filepath = os.path.join(gt_dir, gen_curr.filenames[0].replace('.jpg', '.png'))\n",
+    "G = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth\\n segmentation')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth\\n segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load predicted segmentation\n",
+    "pred_idx = cv2.resize(np.uint8(Y_crf[0]), (G.shape[1], G.shape[0]), interpolation=cv2.INTER_NEAREST)\n",
+    "Y = np.zeros((G.shape[0], G.shape[1], 3))\n",
+    "# Evaluate predicted segmentation\n",
+    "for k, gt_colour in enumerate(colours):\n",
+    "    pred_mask = pred_idx == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "# Obtain overlay\n",
+    "Y_overlay = ((1 - OVERLAY_R) * I / 255.0 + OVERLAY_R * Y / 255.0) * 255"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Overlaid\\n Segmentation')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Predicted\\n Segmentation')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y_overlay.astype('uint8'))\n",
+    "plt.title('Overlaid\\n Segmentation')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/02_hsn_v1_lean-voc2012.ipynb b/02_hsn_v1_lean/02_hsn_v1_lean-voc2012.ipynb
new file mode 100644
index 0000000..c5f32e2
--- /dev/null
+++ b/02_hsn_v1_lean/02_hsn_v1_lean-voc2012.ipynb
@@ -0,0 +1,437 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 02_hsn_v1_lean-voc2012"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import time\n",
+    "import skimage.io as imgio\n",
+    "import pandas as pd\n",
+    "import numpy.matlib\n",
+    "\n",
+    "from adp_cues import ADPCues\n",
+    "from utilities import *\n",
+    "from dataset import Dataset\n",
+    "\n",
+    "MODEL_CNN_ROOT = '../database/models_cnn'\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predict: dataset=VOC2012, model=VGG16\n"
+     ]
+    }
+   ],
+   "source": [
+    "dataset = 'VOC2012'\n",
+    "model_type = 'VGG16'\n",
+    "batch_size = 16\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    size = 321\n",
+    "else:\n",
+    "    size = 224\n",
+    "should_saveimg = False\n",
+    "is_verbose = True\n",
+    "\n",
+    "if model_type in ['VGG16', 'VGG16bg']:\n",
+    "    img_size = 321\n",
+    "else:\n",
+    "    img_size = 224\n",
+    "sess_id = dataset + '_' + model_type\n",
+    "model_dir = os.path.join(MODEL_CNN_ROOT, sess_id)\n",
+    "\n",
+    "if is_verbose:\n",
+    "    print('Predict: dataset=' + dataset + ', model=' + model_type)\n",
+    "\n",
+    "database_dir = os.path.join(os.path.dirname(os.getcwd()), 'database')\n",
+    "if dataset == 'VOC2012':\n",
+    "    devkit_dir = os.path.join(database_dir, 'VOCdevkit', 'VOC2012')\n",
+    "    fgbg_modes = ['fg', 'bg']\n",
+    "    OVERLAY_R = 0.75\n",
+    "elif 'DeepGlobe' in dataset:\n",
+    "    devkit_dir = os.path.join(database_dir, 'DGdevkit')\n",
+    "    fgbg_modes = ['fg']\n",
+    "    OVERLAY_R = 0.25\n",
+    "img_dir = os.path.join(devkit_dir, 'JPEGImages')\n",
+    "gt_dir = os.path.join(devkit_dir, 'SegmentationClassAug')\n",
+    "\n",
+    "out_dir = os.path.join('./out', sess_id)\n",
+    "if not os.path.exists(out_dir):\n",
+    "    os.makedirs(out_dir)\n",
+    "eval_dir = os.path.join('./eval', sess_id)\n",
+    "if not os.path.exists(eval_dir):\n",
+    "    os.makedirs(eval_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load network and data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\framework\\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\keras\\backend\\tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use tf.cast instead.\n",
+      "Found 1449 validated image filenames.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Load network and thresholds\n",
+    "mdl = {}\n",
+    "thresholds = {}\n",
+    "alpha = {}\n",
+    "final_layer = {}\n",
+    "for fgbg_mode in fgbg_modes:\n",
+    "    mdl[fgbg_mode] = build_model(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = load_thresholds(model_dir, sess_id)\n",
+    "    thresholds[fgbg_mode] = np.maximum(np.minimum(thresholds[fgbg_mode], 0), 1 / 3)\n",
+    "    alpha[fgbg_mode], final_layer[fgbg_mode] = get_grad_cam_weights(mdl[fgbg_mode],\n",
+    "                                                                    np.zeros((1, img_size, img_size, 3)))\n",
+    "\n",
+    "# Load data and classes\n",
+    "ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)\n",
+    "class_names, seg_class_names = load_classes(dataset)\n",
+    "colours = get_colours(dataset)\n",
+    "if 'DeepGlobe' in dataset:\n",
+    "    colours = colours[:-1]\n",
+    "gen_curr = ds.set_gens[ds.sets[ds.is_evals.index(True)]]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate segmentations for single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\tBatch #1 of 1\n",
+      "\t\tImage read time: 0.09221 seconds (0.00576 seconds / image)\n",
+      "\t\tGenerating patch confidence scores time: 49.51458 seconds (3.09466 seconds / image)\n",
+      "\t\tGenerating Grad-CAM time: 51.20006 seconds (3.20000 seconds / image)\n",
+      "\t\tFg/Bg modifications time: 0.37858 seconds (0.02366 seconds / image)\n",
+      "\t\tCRF time: 5.80165 seconds (0.36260 seconds / image)\n",
+      "\t\tElapsed time: 106.98709 seconds (6.68669 seconds / image)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Process images in batches\n",
+    "intersects = np.zeros((len(colours)))\n",
+    "unions = np.zeros((len(colours)))\n",
+    "confusion_matrix = np.zeros((len(colours), len(colours)))\n",
+    "gt_count = np.zeros((len(colours)))\n",
+    "n_batches = 1\n",
+    "for iter_batch in range(n_batches):\n",
+    "    batch_start_time = time.time()\n",
+    "    if is_verbose:\n",
+    "        print('\\tBatch #%d of %d' % (iter_batch + 1, n_batches))\n",
+    "    start_idx = iter_batch * batch_size\n",
+    "    end_idx = min(start_idx + batch_size - 1, len(gen_curr.filenames) - 1)\n",
+    "    cur_batch_sz = end_idx - start_idx + 1\n",
+    "\n",
+    "    # Image reading\n",
+    "    start_time = time.time()\n",
+    "    img_batch_norm, img_batch = read_batch(gen_curr.directory, gen_curr.filenames[start_idx:end_idx + 1],\n",
+    "                                           cur_batch_sz, (img_size, img_size), dataset)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                      (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate patch confidence scores\n",
+    "    start_time = time.time()\n",
+    "    predicted_scores = {}\n",
+    "    is_pass_threshold = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        predicted_scores[fgbg_mode] = mdl[fgbg_mode].predict(img_batch_norm)\n",
+    "        is_pass_threshold[fgbg_mode] = np.greater_equal(predicted_scores[fgbg_mode], thresholds[fgbg_mode])\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %\n",
+    "                                            (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Generate Grad-CAM\n",
+    "    start_time = time.time()\n",
+    "    H = {}\n",
+    "    for fgbg_mode in fgbg_modes:\n",
+    "        H[fgbg_mode] = grad_cam(mdl[fgbg_mode], alpha[fgbg_mode], img_batch_norm, is_pass_threshold[fgbg_mode],\n",
+    "                                final_layer[fgbg_mode], predicted_scores[fgbg_mode], orig_sz=[img_size, img_size],\n",
+    "                                should_upsample=True)\n",
+    "        H[fgbg_mode] = np.transpose(H[fgbg_mode], (0, 3, 1, 2))\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # Modify fg Grad-CAM with bg activation\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        Y_gradcam = np.zeros((cur_batch_sz, len(seg_class_names), img_size, img_size))\n",
+    "        mode = 'mult'\n",
+    "        if mode == 'mult':\n",
+    "            X_bg = np.sum(H['bg'], axis=1)\n",
+    "            Y_gradcam[:, 0] = 0.15 * scipy.special.expit(np.max(X_bg) - X_bg)\n",
+    "        Y_gradcam[:, 1:] = H['fg']\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        Y_gradcam = H['fg'][:, :-1, :, :]\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                     (time.time() - start_time) / cur_batch_sz))\n",
+    "\n",
+    "    # FC-CRF\n",
+    "    start_time = time.time()\n",
+    "    if dataset == 'VOC2012':\n",
+    "        dcrf_config = np.array([3 / 4, 3, 80 / 4, 13, 10, 10])  # test (since 2448 / 500 = 4.896 ~= 4)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        dcrf_config = np.array([3, 3, 80, 13, 10, 10])  # test\n",
+    "    Y_crf = dcrf_process(Y_gradcam, img_batch, dcrf_config)\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,\n",
+    "                                                                 (time.time() - start_time) / cur_batch_sz))\n",
+    "    elapsed_time = time.time() - batch_start_time\n",
+    "    if is_verbose:\n",
+    "        print('\\t\\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))\n",
+    "\n",
+    "    if dataset == 'VOC2012':\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_idx.shape[1], gt_idx.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k in range(len(colours)):\n",
+    "                intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))\n",
+    "                unions[k] += np.sum((gt_idx == k) | (pred_idx == k))\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_idx == k], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_idx == k)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 +\n",
+    "                             OVERLAY_R * pred_segmask / 256.0)\n",
+    "    elif 'DeepGlobe' in dataset:\n",
+    "        for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):\n",
+    "            # Load GT segmentation\n",
+    "            gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))\n",
+    "            gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)\n",
+    "            gt_r = gt_curr[:, :, 0]\n",
+    "            gt_g = gt_curr[:, :, 1]\n",
+    "            gt_b = gt_curr[:, :, 2]\n",
+    "            # Load predicted segmentation\n",
+    "            pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_curr.shape[1], gt_curr.shape[0]),\n",
+    "                                  interpolation=cv2.INTER_NEAREST)\n",
+    "            pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "            # Evaluate predicted segmentation\n",
+    "            for k, gt_colour in enumerate(colours):\n",
+    "                gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])\n",
+    "                pred_mask = pred_idx == k\n",
+    "                intersects[k] += np.sum(gt_mask & pred_mask)\n",
+    "                unions[k] += np.sum(gt_mask | pred_mask)\n",
+    "                confusion_matrix[k, :] += np.bincount(pred_idx[gt_mask], minlength=len(colours))\n",
+    "                pred_segmask += np.expand_dims(pred_mask, axis=2) * \\\n",
+    "                                np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "                gt_count[k] += np.sum(gt_mask)\n",
+    "            # Save outputted segmentation to file\n",
+    "            if should_saveimg:\n",
+    "                orig_filepath = os.path.join(img_dir, filename)\n",
+    "                orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)\n",
+    "                orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))\n",
+    "                pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),\n",
+    "                                          interpolation=cv2.INTER_NEAREST)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)\n",
+    "                imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),\n",
+    "                             (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Show sample segmentations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "img_filepath = os.path.join(gen_curr.directory, gen_curr.filenames[0])\n",
+    "I = cv2.cvtColor(cv2.imread(img_filepath), cv2.COLOR_BGR2RGB)\n",
+    "gt_filepath = os.path.join(gt_dir, gen_curr.filenames[0].replace('.jpg', '.png'))\n",
+    "gt_idx = np.expand_dims(cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0], axis=0)\n",
+    "G = maxconf_class_as_colour(gt_idx, colours, gt_idx.shape[1:3])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth\\n segmentation')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(I.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G[0].astype('uint8'))\n",
+    "plt.title('Ground truth\\n segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load predicted segmentation\n",
+    "pred_idx = cv2.resize(np.uint8(Y_crf[0]), (gt_idx.shape[2], gt_idx.shape[1]), interpolation=cv2.INTER_NEAREST)\n",
+    "Y = np.zeros((gt_idx.shape[1], gt_idx.shape[2], 3))\n",
+    "# Evaluate predicted segmentation\n",
+    "for k in range(len(colours)):\n",
+    "    Y += np.expand_dims(pred_idx == k, axis=2) * np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)\n",
+    "# Obtain overlay\n",
+    "Y_overlay = (1 - OVERLAY_R) * I.astype('uint8') + OVERLAY_R * Y"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Overlaid\\n Segmentation')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACtCAYAAABLEj8DAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9eZxky1Xf+T13za32rffutyG9pw3JCPgwYgYPHswyshgbeTAf0MKiBeMBPmAjDMZljxkzDP7Ywv4MIODp6UlsAoOHmWG1MMsYZIMEWt7+Xne/rt6ra8/1LhHzR8TNvJWdVZVVXUt3v/vrT3Zm3hs3Iu6tyBMnzvmdE6K1pkCBAgUK3F9wjroDBQoUKFBg/1EI9wIFChS4D1EI9wIFChS4D1EI9wIFChS4D1EI9wIFChS4D1EI9wIFChS4D1EI97scInJORLSIePb7b4vIOw+h3XkR+dhBt1OgwHawY//hIcqdEZG6iLhbnH/FjedCuO8TROSiiLTsALshIh8Wkdp+t6O1/hqt9UeG7M/f2O/2CxQQkXeJyOdEpCki10Xkp0Rk/Cj7pLW+pLWuaa3To+zH3YRCuO8v3qq1rgFvAt4M/HD+pBgUz7zAPQsR+T7gfwf+ITAGfClwFvh9EQn2sR1vv+p6paIQNAcArfUV4LeB14rIH4rIj4rIfwaawIMiMiYiPy8i10Tkioj8i2w5KSKuiPyEiNwSkfPA1+XrtvV9e+77d4jIMyKyISJPi8ibROSjwBng/7YriX9ky36piPypiKyKyGdE5Cty9TwgIn9k6/l9YPqAH1OBewwiMgr8M+AfaK1/R2sda60vAn8XI+C/365eJ3PXvNGOZd9+/1Y7XldE5HdF5GyurBaRvy8iLwAvDGj/60TkL0VkXUQWRGQ+d67ffPmKH8+FcD8AiMhp4GuBv7SHvgV4DzACvAx8BEiAh4E3Al8FZAL7O4D/0R7/IuAbtmnn7cA88A5gFPhbwJLW+luAS9iVhNb6x0XkJPD/Av8CmAS+H/j3IjJjq/tF4FOYH8H/Chy4Xb/APYcvA0rAr+cPaq3rGGXmdcCfAX8nd/qbgF/TWsci8vXAPwb+NjAD/AnwS31tfD3wJcBjA9pvYMb6OEbpeb+tcxCK8ay1Ll778AIuAnVgFSPA/0+gDPwh8M9z5eaADlDOHft7wH+yn/8AeF/u3FcBGvDs9z8Evt1+/l3gu7fpz9/Iff8B4KN9ZX4XM+jPYCabau7cLwIfO+rnWrzunhfwzcD1Lc79GPD7GCXlD+wxARaA/9Z+/23g23LXOJjV7Fn7XQP/fV+9Gnh4izb/DfCv7edz2e+kGM/mVdi19hdfr7X+j/kDIgJmgGc4C/jANXsOzCDPypzoK//yNu2dBl4asm9ngbeLyFtzx3zgP9k2V7TWjb52Tw9Zd4FXBm4B0yLiaa2TvnPH7flfA/6tiJwAHsEI3D+xZc4CHxSRf5W7ToCT9MZ5fuxvgoh8CWYSeS0QACHwqwOKFuOZwixzWMin3lzAaO7TWutx+xrVWr/Gnr/G5kF4Zpt6F4CHhmgzK/vRXJvjWuuq1vrHbJsTIlIdst0Cr0z8GWbs/u38QTtuvgb4hNZ6Ffg9jB3+m4Bf0lZ1xozB9/aNwbLW+k9z1W2XpvYXgd8ETmutx4CfxkwO/SjGM4VwP3Rora9hBv+/EpFREXFE5CER+e9skY8D/4uInBKRCeAD21T3cxgn1l+zTJyHcw6qG8CDubIfA94qIn/TOm1LIvIVInJKa/0y8BfAPxORQETeAryVAgVy0FqvYRyq/1ZEvlpEfBE5h9GeLwMftUV/EWMb/zv2c4afBn5QRF4DYIkFb99FF0aAZa11W0S+GDN5DOpnMZ4phPtR4R2YZeXTwApmKXvcnvtZjC38M8Cn6XNe5aG1/lXgRzE/oA3gP2CcpQD/Evhhy4z5fq31AvA2jENrEaNF/UN6Y+CbMI6sZeCfAk/ux40WuL+gtf5xzBj6CWAd+C+YsfSVWuuOLfabGJPMDa31Z3LX/gaGRvnLIrIOfB6j8Q+L7wT+uYhsAD+CUYS2wit+PEtvxVSgQIECBe4XFJp7gQIFCtyHKIR7gQIFCtyHKIR7gQIFCtyHKIR7gQIFCtyHKIR7gW0hh5RiuECBw8b9PrYL4b4FRORtIvJXNknRLRH5hOX03jPoTzI2RPnbcl7rIVMMF7h3UIxtg/t9bBfpBwZAzOYAT2Ii8f4AqGFyvKij7FeBAneKYmy/gnDUyW3uxhcmE+NfbXPewUSOvgQsYYIpJnPn34HJZbEE/BNySbwwWRx/FRMxugF8DvgC4AeBm5iAkK/K1TUG/DwmpPoKJquja8+9C/j/MAElK8AF4GvsuR8FUqCNSWj27+zxD9o21jFZ877cHv9qIAJiW/4z9vgf0ktU5mBy1L9s+/okMGbPncOEjr8Tk5HyFvBDR/23LF7F2H6lju0j78Dd+MKE7beBfw38daDWd/57gE8CpzDJi34Gk0MDTKrSOvAWTBTqT9hBlf8BtIG/iVk5PWkH7g9hEnl9B3Ah19Z/sPVXgVngv2Lyc2Q/gNhe4wLvB67SC07rDt5cfd8MTNm2vw+4DpRyfftYX/n8D+BbgRft86lhomc/2vcD+FlMNsw3YPKQPHrUf8/iVYztV+LYPvIO3K0vzA4zH8eE6reBJ7IfAvAMJtw6K3vcDkQPExb9S7lzFYzWkP8B/H7u/FvtDybTWEbsQBpn5/TA7wJe7GtLA8f6B+8297kCvCHXt+1+AJ8AvjN37lW5+85+AKdy5/8r8I1H/bcsXsXYfiWO7cLmvgW01p/EZLZDRN4M/ApGA/lBTOrS3xCRvJ0yxQzYTSl7tdZNEVnqq/5G7nMLuKV7ez+27HvN1rVdemAw2km+rezagRCzTdq327o1ZpOPYXepOcHmFMQvYwb/3KD+YHJ17/s+sgXuDMXYHoj7bmwXwn0IaK3/XER+HZNHGswA/Fat9X/uLysi1zCzfva9jFkq7gX59MD9+bOHwabEQSLy5ZhNO74SeEprrURkhV7a1J0SDV3F/PgzZJsi3MAs4wvcYyjGdhf33dguqJADICJvEbM36az9/mrMFnaftEV+GvjRLL2uiMyIyNvsuV/DpNb9MjEbBv8zBuec3hF65/TAO6E/7e8IZsAuAp6I/AhGu8mXPydbb+L9S8D32v0pa8D/BvzKHn+cBY4Axdh+5YztQrgPxipmwH9OROrA7wC/Afy4Pf9BTFrT37PpRz+JSS+K1vop4B8Av4xhAWxgvO8d9obt0gPvhA8C3yBmM+KfxKQS/m3gecyys83mZXC2q82SiHx6QH2PY3J2/zHGUdbG3GuBewfF2H6FjO0i5e8Bw2oBq8AjWusLR92fAgX2C8XYvrtRaO4HABF5q4hUxGzz9RMYvu/Fo+1VgQJ3jmJs3zs4EOFut+B6TkReFJHttom7X/E2jIPmKmZHmm/UxRLpvkAxtouxfa9g380yIuJi7F7/A2ZfxT8H/p7W+ul9bahAgUNGMbYL3Es4CM39izHBB+e11hHG+fK2Ha4pUOBeQDG2C9wzOAie+0k2e6kvY73tW0FEimVdgQOF1npPlL0+7Hpse56nwzC844ZFBK01uYCfAgXodDrEcTxwUByEcB/U0G3CW0TeA7znANovUOCgsOuxHQQBjz32WHZ8SwG9ldC+07KbOrqNCTY7t10dw5TZCv3X7PQc8ucPY0LL31u+7d2arfuvHfR52HqHKfPZz352y3MHYZa5DJzOfT+Fcb5sgtb6Q1rrL9Jaf9EB9KFAgYPArse253n545t+4Lv9sW9XNhNKg87n8qFsCRHZVqDlj92Jn27YSWSvz2avyN//XgV7/trtPm93bDfYqX8HIdz/HHjERnoFwDdigiIKFLjXcUdjezvtdb9+6FmdeYG+27r7Bet+CNesnmFWF68E09Mw9zjMKmo77LtZRmudiMh3YSLGXOBxG9lWoMA9jYMY23sVeNtdt58CMr8i2I82dppw7hbfwmGsFoYxk90JDiRxmNb6t4DfOoi6CxQ4Sux1bO/GDNF/bq/Ia/FbCelh2tzNtcPgXhDs+33Pu617pzLD1FFEqBYocAi4UwfaIPPITuV3Y/LpL7OTzftOhN9W191NsVAH1ZednttWfpP8+WFNZYVwL1DgELCdgL1T++tWyAuCnYRB/nx+Usg7Gne6brd9G4SDcDzeCfaz7b2unPLY6e+RRyHcCxQ4YuxG+O5Ge98PbNW3O233MAT2bts4iPvMY1itfdi6dkIh3AsUuEuwV4F3kAI+r71vpVX3TwB7NUENMg3dySSw2+eym7a2M2PtR1/2o65CuBcocJeg34xyUFrzbvuUfx/E2smO75V6udU1R2GD328zU4ZhtPZhn9uw/o5CuBcocEgYRgDk3/s/77auO9V8s3qGpWsO06+drr/bsNUz3G9N/E7YTFuhEO4FChwC9iIgt4s6Haa9vVwzCAdlLtovx+F+YatV0lYmpH7H807YiQK6l/5th2KD7AIFDhH9gns3S/FBdQ2iLA4Tuj+IHbNVnbulPQ6yv+/EghlmtbKfGDSBDsJWcQLD+hj2M1Bpt8+l0NwLFDgk7IfTcacywwiA3TBu9kPQ7lTHQQj2Ye3be2Up3WkfYPems92uxgrNvUCBI8RWGnR/me2W9P1ldnJsDtJW+68Z1OawAnEYHLR2flTc+GEn5N04WPf6vAvhXqDAXYBh7fHb5ZjZj9VAVt8g085+CfVBE8udCuP+SXInds9+3MsgIb0f9vP96mMh3AsUuAswjG06/6Mf1vwySPse1gyz3wyWYdhAW5mZ+iex7e5jt+avfNk7DXzayinbf8+HwQ4qbO4FChwwhv0hb2eWyQu0nQTiXts5aOyFs98vqPdT8+7HQdm+84FeO127n/dVCPcCBQ4Bw/yw+8sPOrZfeV4GadH5eg5KeO5EN9zLBHAY2O3fr/+6Ycxu+0VdzVAI9wIFDhlb/ZB3st0OI9gHmQny5/qF1G6YM3sp19+3ne7hMMP4DwP76YTeLQqbe4ECdxG2Y8/sxILZro79FC7bOXH36hjuP3+ndezE/x+m/r1gL5PeQaHQ3AsUOCJstxTfScMd1vZ8UCaWQW3fSbDTXtsftCoZxGDpL7NXM8vdgGH7XGjuBQocMrbjkmcYlrkxiPa3k9N1Lw7VYVkhu6lvKyF8p9it03Uvtu69sor22lb+bzzsJFoI9wIFDglbBQVtV3anCSArm9dCd2MaGSQ8+tu9U+HX32b/sUHl+vvSf+1W1+wnBtW7l2eyHyuU/N942EmwEO4FChwC9sKf3q3mnr92qzI7BSdt9Xm32Kr/w0xWw37fq6a/mz7s9vyw7Qx7bf/EvZs+FMK9QIEDxl5+4NtRFfNlduOAPGxsJ+Az7Gdkar7O/RTSWfndBI7t1jS0XX17ReFQLVDgLsAwwrwfe9EM79RWvlscRd17nTwGOWe3ctpudV32vhdK56D2dltHHjsKdxF5XERuisjnc8cmReT3ReQF+z5hj4uI/KSIvCginxWRN+1Uf4ECR4XDGtu70a4P2hmYXbOd4Brmlb9m2PZ26kv+fga1txcopba8763uaRjsdN0wpq79usetMIzm/gTw1X3HPgB8Qmv9CPAJ+x3ga4BH7Os9wE/tTzcLFDgQPMFdNLYzG+vdgN06ZbcSTrthlWwlKPvD97MyOwnk3U5C+bL7KWz7zUT7Ufcwdewo3LXWfwws9x1+G/AR+/kjwNfnjj+pDT4JjIvI8aF7XKDAIeJuG9t5oXLUQn4vK4dBgnE7jXavfRlU/1aa+E717pf2PKymfpjYq819Tmt9DcC+z9rjJ4GFXLnL9thtEJH3iMhfiMhf7LEPBQocBPZ1bCdJsi+88nsNexHwhyEIhxXkd8JyyX/ebWDXTnXvZhLab7bMoCcysCda6w8BHwIQkXt7JBd4JWBPY7tare44tvv55gelte+noIGdHYfbrUJ2K+C3akdENtnVt8JWlNE7edbDrijutN69Yq+a+41sSWrfb9rjl4HTuXKngKt7716BAoeOQx3beZbMQQp22F9t+KD7Oqi97D3/StOU5557Dtd1t/VZDLr33Ux2+2nC2a5v+1nvXoX7bwLvtJ/fCfxfuePvsMyCLwXWsiVugQL3CA5kbA+KTt1NxGr/+b0IVsfZ7ud+uNGfgxvb4fRtmjK4nsfMzCwrqyvmmFJ3/BzzUagHxWQZhN22s1P5Hc0yIvJLwFcA0yJyGfinwI8BHxeRbwMuAW+3xX8L+FrgRaAJvHuYTh4HDnoGmN/juQL3Lw5jbE+xNw77EH3H931c1+Xd24TEP2GPJ0lCkiQoK/wcx+krvzPbZZjjgzCM7XkQq2Y7LdxMjtCsN0iSBK1Tc/y2+xp8/Z2c36o/u8VB+xjkbnDcnBDR77Wf5++gnju59ijqLXB40FofCf3kbLWqf+A1rwGMoN0LRIT3lUrA9oJkWKGY//5zSUIcxztecxhmGMFMMcOaS0SE559/kcnJCUSEqanJIzMX9T/XYXwR+9H2008/TaPRGNjYXZd+YH6XZYYpf6fob+Mw2ixw/yD7ob+b252E/T/0J+y71prvrFQGsi/y33dCv2NvszASvt3zwPOsU1L4mU57gFa/tdM3X99t5zVbWXu26KspP6xg11pTqY4A4HmePd6774MQ8sM4gncqu5/tboe7TrgPg/kjaG++7/ugzwUK7ITt7Oxaa94FhGEIQJqmW2YhzAvVzNSynUATERqNOr7v4zgOSmniOOFxlfLdY2MsLS0zPT3N+8vlbt0/3W7f1v5WLJB+wa61NnJdQ1fCd1XzzdfkagGGWyVoDSrVhJ4LOmVsbJJel26fyAbVeZBWizuhQQ6aPPeCe1K4Hzbmd3Fuu7IFCuSxlZPVHM4kIWit0FoQ0WgtpKnCdc07GEdpmqY4roNWunusH5VKhSiK8DwPrcH3fb5TKTqdDpOTE6yurnDjxiIPP/wQruvwvlJIo9FgdHSMKIr42Tju1p2fUDLcNgH0zmx6y5v3bxNeO1AI80KvVA4JA6HsB3ieTxQnOGh0/3LhDmiJd4LdMHH2eu12KIT7PmCenlDvfy9QYCtkTAwRod1pcfPmTQI/xHFc0lShVIrSKYEfApqlpRVmZ6fQ2mjrKyvLhKUSc7OzjNRGUKon1lQfa0RrjeM4eJ5PpxMRhiFKKRzH6b5GR0e5cvkaizdvMTs3zcWLC/xMp8P3TXa4tXSLt47UOHnyFD+XxF1uuQgcpszsCT3N5YWrBG5CWKmaVY7W6EGcevu+3zz/YbCVCWu/6t4ORVbIO8Q8gwX5/DbnCryysN2P0HGE5ZUlok7ESG2EpaUlkjRFaYUIeK5n2SDwhV/4RhzHx/N8wrDM7OwMoR+wvLzMU08/tUlf7edk500Tvu93hbNSCq01URQB8KpXP0ySKlzX5XeOzfK94xOsr68zNTWNVnDlyhW+ww94f7nM+0qlrn2+t+o4nPw4WsP6et3cH8aEBcoIcm1eW5mydrKb91Mgt1qdbEeV7L++30R0GDTLQrjfIeaHODfP0Qr7o2izwDAw2jRaSFNNuVxhcnIS13UQ0ZRKJarVKn7gsb5ep76xjtZGsKVpSqlURlu9dGJinM989jO3CRXXdVlZWena5rPz7XbbCuWeVm/Ow9zcNM8/d4H3hmVW19Z45AseZmpyivGJSZRSXLhwgZ9LUur1Bu8Ny7y/XOG9YYlvtaagfmF/EM9NxKFWq/EO7dCOUvNcAJ37l/VlkCDtP76dLyFfflCZ7drZLzv/Vv3dDoVZ5gAxP8TxrcoUuL+QCdIepPs6efKk1c4V4+NjaGWEVJomdDoRExOTzM0meJ5PqRywvLxmeOtxSqPRoFqpkKYps7OzuK67KRzfcRxmZ2dpNpvdKE6lFOVyiXarQxgGuI5DqlI67YiwFKI1nD5zjOeeex4R4fOff5rx8XFOnDhBEAScP/8if2t5heVWi9HREdbW1mybmvdNTnbNPT/VauGIQ0acuf2h5B6F1cCl79TtMCXiKEXE3F8zihivirm+/0K96bKBWvjdFBW8X85UKIT7kWN+i88HUX+Bw0e/vTdzlmaMmOy4cYA6gKBR3WOlUsnaz3tOzMnJ8a45pFqrICI0m03q9ToLCwucOHGiW28URbiuS7vdZmRkpNuvJEkJwgANNJpNgiCwgt0sDTzX5ZFHHkRrQ5GMopgXX3yBZrPJ6173OhZv3uLcA2e5fPkaQRDQ6bQplUrcurXExsY6DzzwAO8vlwGzyvjZOMYRS7G0wrwrcM2D2OwG3VKwmf4sLFzlu0bKIEKaJD1zTK6STRo0m/0P22nUh8mTz7e/X0I9QyHc7yLM970XuH+QX9KHYbjJ9podF5FN9MfMTJKvI2PTZNp5EARorRkbG2N0dNRem1+2a5RSjIyMoLXe5Gg1UasxGxsbTE5OdTVupU3OloWFBc6ePYPnebiuy7lzZ20/FK7n8OlP/yW+7wMwPT3DzPQUGqjXG9y6tcTMzLRl9ri8z3URhMe1IupE3UhSETGOUNPVbp8ZIGDNPZmVh+e5dkUglHLxAMJwwrHfBr7Vua2u3WtEar69rWimu6lvu5QNd12EaoGdMb/HMsNcd79CH1GE6plqVX/ARqiCEcb9QUL9Tk8wgjePnfKhZEI+jmOMcM/KYu30twdANZtNarUqnud1o1Tb7TZhWEIE2u0Oo6MjvPjiS8zOTFMql3Ech0a9wejYGGlqQv49z6der3Px4kWUUkxOTJIkCWvra7z2ta+5zf6e/R8nMSpVm7TtJzRde3ke5rlowOG9YcjFCwu4nuD7LuNjo3wYZ9N8sJUmfFCMmX6Of/54vj/71XZWzzPPPEOz2bw3IlQL7Iz5Hb4XuLuQ/RB939+ksee54nktvnfcaO6DhEJPUGvOnz/PuXMP4Hmetanr7rVb9QWgVCqRpikqVXSiiCAIEGs60VpTqZRptdqIGDOO1rC+voFSKcsrS4yOjOJ5Ps1mg2q1zGOPvdpOSg7tdpt2p8PFixc5d+7cpsAmZfvteR54PcGXxDHvznjq5sZNxK79nN3b+Zcu4jgugrG5h6UyjmX7ZLb7/ASaF7D7JVx34vgPet7btb0b4T/sqqEQ7vcB5rf4vFWZAocNY07Q2iTwGiTQ+wVP/96f29mIwzCkVApptztorbl06RLnzp27jeueCb4MXaGHxvd9tNb4vtetO4piHMdhbnYWzzPml/GxMZI06bJrFhYu4boui4sxJ06cRMQBDdVKmUcefpDU3kf3PtksnPL35vk+mX0miiIcgXepnm3+CRvY5To+4ii0nSAeVwpHBGXNNlntkgsEy+43b/nJnsZeNOqD0P6HrXPYcoVwv88wf9QdKDAQcRzdLmzJm2SyI3mbbOZXNNGp/cjb15WCT3/6L3nooYeYnp7p2u43aY5912utNkWb5o0mmaC/du1al+deq9XodDp4notWGtdzOXbsOKBZWLhsJ68Yx3FJEo3j2sjZnH09cxQPMleICEobZ3IQGueu6pqZNO9CU2+02XDMw3Ecc53huHcfym13OlAUihX+1tpz+1V3jq2ctHdCh8zXtVM9hc39FYT5o+7AEeIobe4/8NijrK2t4Qe+oepltud+W7Q49PEDcxJHECezUOTt7xCGJmNkpxMRBD4vvvgip0+f7mPiGGTmIMdxcF3HCuKETKi7rjF9ZGWzfvbaM+YiMdKx228BlM5WG7JJAHmeR71eZ2xsbNMKJR9MtZ32rFTadR5evLhAuVKh02nheR6+7zE1NcmHewp+zhylB38f0MadyMHtnLN3Ut8g9Av2Z599trC5Fyj49UcFEcF1HaJOlohLzD/XwREHBPNOjykjGKGprJ1aHEGldG3WGaUSNK1Wk1KpTKOxwUsvXefMmTOojHUjGGGtM5NItiLQvPzyRcbHxymVyriua6mKDo1Gg4rlzue58T0TyuYJSESjMgcuxjwi0vucJAmjo6MkSUIQBFy8eIFqtcbk5CSXLy8QRTEPPvggvu/fZrYyk5DXXV08+NA5GxNgzE9aBwB8a24V80S3j/19zcGaZfYrqdggG/wg2/h2bQ1yym5l2x8GhXB/BWKegnZ52JiYGOf69WvU6018P8D3fSqWwmeEoDIatXTVYRynJ5i06jFqjMew53TUWtFsNgiCgAcffIg0TcDaoEWDFt2llhuWuBEa7VaLuuuyurxqzBTioFRKqVyxzlVBpSlKpbYXQqqMwFeZ9k4W+m8pmrrXluM66NT0O0tv0Gq1mJs71qWDnjp1mk6nw/Xr15mamqLRaOC6LqVSqcvx35z1Epv4THUnhCzaFjRPAO+yAv2Jrk0d8lp8d140RwaaTLrPWbYWqNsJ3a3YM4PK5o9vNUnsZXVQmGUKvCIE/JFSIR97DI3i+eefw3U9a6/u6VWua3jkXbuzNVWkaYLrepRKIY7jEAQhnufiuR6ZOzCfUqBr5rF2e4022jibaeOO49BptymVy2iliOOYOIrpRB3i2ETEiuPiusY52tvdqEex9D2vq6GbOl2USs0EkaZoNJVKhWvXrtNqtXBdl7GxMVqtFjMzM2htUiNkNn/P8/A8j1u3bqGUolQqkSQJ9XqdcrnM9PQ0cRwPzDWv0hTXc00wk96ssT8x4G/SMw31zFaeTYWstSbqdHplN1+4+di2/ozdsV+2EuyDBH1mZvM8j6eeemrLzToK4V5gT5g/6g7sEkcl3OdcV//wG95ghE+acPHiBZTSKBvcI/aHKiJ4ntcN+skLbKOp9oR3hn7zRXY+LxQyZ2NGk/R9jyAIusFHWmu00iituiYiq67iBz5pmlo+O7iuEfhpkua46JtTFPu+z/raOlEUMTU1tXnbOxHiKGJ0dNQ6Zs0E5ziObbZ3b5nG7vumD2tra1QqFdbX17v3OzIyQhiGJElinpFSJElEq9Wm2WywsrJKq9VEK2MaGhsdpVKtEpZCQj9Eo2l3OjQaDeI4plqrMjkxyccrFZNOuWvqwTCNtLnr7PmaHEAOjiP23bHplxO0FhNrrDVoRZKmRFFMmia022YSjaKITqdDHMddc5RSCt8LEMdMmEHgdyc/M/mYv0Nqt0xcWV0lSZLC5l5gb5hns9H6lPoAACAASURBVCmnwPAwQhW7cbPDIw9/AecvvESs7X6mupe0K1ZGCHiev0mQZwFG/dzt/Pe8YzKzlQNdoZ+ZNjqdiE4n6p7L0KNpms9hGOJHgQ26ctHapCBOkhgQYz4S6wHQVlMWod1qo9Gsr69TG6mxvrbB0vISjz76KK1229xnHFOpVOh0Ot0NPbSIdTZnGqpx+MZxjOu6jIyMkCQJ09PTaK3pdDpsbGywsbHB6NgYcRyzvrZqBapZzVTKJTzPtYFSYjnxJSYmJghDk0Pnw9pskPKk4yKOuQ8nVYh1NMexeSZZ7EC2D22r1aLdbtsyJhgrSc2z8TwX1w3wPLOKyjZHyT9zpVJ836fT6jA5PUGSpHb1oyiVQjzPo1QqEYYmBbRYdlCSpIC27yZ1xFYoNPcCwJ3Z4PdyzWHjqDT3k6WS/qHXvdYIYck0Ypfnnn3e0hXzDBmwxm8gEwS9zxk10rPb4mWTQv/GHDtFs/bYObeHwkNv+e97HnGcgNBdTYCJns201DAMCILQ2qg1qUqtucjY2cMw7AYbOSI4jovjOpTLZVSaEiexmQARxOlFmWariE3yKbPjazNZKq1JkxjfD8zkJqCVJoojWs0mY2PjrK2v8QuejzgO78rdX5qmxFGHdqdDmiS0222iOAGtiOPEMokcfsFuQp49I/PMbB9du+rK+PeuS6pMwrd6vYlSMdPTM8bk5HpUqhUCP7B/LxOs9fKFBU6emQMttzGh+v9Gg/Dcc88VbJkC22P+qDtwn6JHX+9FaEadhAcePMelly/ZQKFMM9aIA2J/5Nm+ptlOSyJmqZ7ZnjMhm3Ha+5kf/d/zNv18mexcr6umTJTbODsz72S28uxzu92xUaxiWT9CEifWlp9QmvQpVcpoMHnqUaRxShiGLK+sMDszSyfqEHVa+EHQZcIIPfNH3q+glDJRtdZsE1tNOokT4iSx+XLMc/GuXafZbPIV5QpoxSUrsJM0BQ2e7+G5LkppfD8gDEtorbqOZA24SuE6LhpNEARdbXptbYNKpcTC5Su87nWvNc7mNLW7Y2leeukCtZFRZmdnyaJ+wdBFVZoxjxzKlQq3bt1iemomP1q6GMaZuxV2FO4ichp4EjiGcbZ/SGv9QRGZBH4FOAdcBP6u1npFzGj4IPC1QBN4l9b60zv2pMBdi/kB3/uP3Ys4jLHdtdHmjlWqFT79qc8g4jA1Ncnq2hJaWTOM0iiMCaffXad19qPOUhNotO6ZX/JJx7JjmX26P4BqkIaYBRH1TAmbo0uzOqMo2uTcy7JWOq7QjmzQEdBsN6klI1x49mVGR0dZXFzkxIkTtNttwKwGGo0GjUbDCGQxWwdmztvMlJIJ9vwqIzM9KWVs312/A5pKuczcsTmq1SrPPPMMo6M1Aj+g3W5RrzdotVporXnLl385H+p0SNOENFG0O22+RSV8vFLtpio+pzPyafdBobVm6dYKS8tLTE9OkyYJiGNNbyYK9tFHH+XatQUbOZt38WYauqluamqMVGVBWJkzuG8MDWDMDINhNutIgO/TWj8KfCnw90XkMeADwCe01o8An7DfAb4GeMS+3gP81FA9KXBPYf6oO7A/OPCx7fs+YalMqVSiXC4ThCGO4/FFb/5rvPFNX8jZc+esqUK6wUTmN6wR+9JKoTNBq5TV8hXozPGYGieeUl3qYmZDz0wQmaa71SvTeLUy5VutVu9YTrjmteienV5QKiXqGAdhFJn0vmOjY7TbbaanpwFjTlpeXqbVanU36o6iiPX1dZQ2+W3ixEwOmYae77vWJjFaHMeEljlUqZSoVExqYdd1OXX6NNMzM6ytrtFutzl58hSVSpWr166xvLJKpxPh+T6u5/Jnf/anJElCmirEEcbHx1laXOJbcquUvMlMxDGTsIYTYx3GqiVOnz6J1nSfu5kkHZIk4tSpM3biyzNscm86y4Pj0h/4ZdALCtsL131HzV1rfQ24Zj9viMgzwEngbcBX2GIfAf4Q+AF7/EltevBJERkXkeO2ngL3IOb73u8XHMbYzqiGRmBp6xRLuvbVJIlptlqMj46jVQvHARcPpUDpFJMiQEgSY1N2HZc0TfFsLhjjBBSUTru8cxNWb2zSRtDT3cQjnwogwyDTzCBqZn+Z7Huapl1HYzYBdDody65xu5tyh2FobO2ZSSWOKZVKuK5Lp93pOp+VtvcqDp7v2eyVI2ilCMOQer1u7fkBDzzwYLetrO2xsRrj4+Osr691tXxEjGO1G6VqmDtfv7bK+NgYH9bGcT07O0ulXEbHCYJD12EsduUgmhdfuEDFWWF86jixdaL6oY9oTRIngNnLtdVqdTX9TUId3d1UZLCuDlke/WwV1J8nZxjsyuYuIueANwL/BZjLBrXW+pqIzNpiJ4GF3GWX7bFNPwAReQ9G+2FsV10usJ+YZ/c7Rm1V/l7GQY3tySBgaekW1Wq1yznPHI8ZjbBcKtNqd2i2WhybnaPZrKN0YgWxg1YazzPml9jak1WaGs68Nto9gELhZJq/DVxS2nDdsxwv/ZkojR80x7OGrgNUa8M8QfdYN3mKZp6pk39lDt68mSiKou5313W7VMjV1VVmZma6phKTt8Zo7Z7nkSQpkxOTTE1N8exzzzEyUjNsmajDa1/3Gj73uc+bdrVCK025XObRRx+l2Wzya7URvslmu3QEqiNVTp8+zejICB+KIpI05VOdDu9Rhk2jVMovl0sQx5bD7qDFaO+ZoPe9Clp7VGozvHDhGq8dmTXOYG3SNiRoHK0tFdKK7a4gV4ChTmbsma0MLCIuqUopl0qGVSS9GIMMO2nwQwt3EakB/x74Hq31+jZ2n4ET0W0HtP4Q8CEwbJlh+1FgfzE/5LH7GQc5tk9XKrpcLvPcs8+igYcffpgoitHaarupohSGtNttKuUyCKRKMzo6SqvVMsLYcWwEq8YVy3X2XJTKBe1kwtayVkzSLoXjumQho2madAWOCWzKh+lnFHchVaqrJ+Zt3nnhrpTapC33lzFb+ZXpdDpdYZ/5BQzLJiRN026ZSqXC0tJSNyBJRFhb32BifAyNZmV1lTOnT9PudNjYqBOGIZ/+9KdvE3jNZpNPfepT+J7PNzz8EE5YohN3OHv2LLVajSe0hlare7/dvmOya7bbHc6/8BIPPHQWx9WINs5UrTWlco2nn3oWheLGKkzNHkPE7HergNBNiOpXkcpJHG1WU/SRtOovX2X07CxaZ5uN2Chietp51q+F8y8xOj7J+OSEnfj8Li12GAwl3EXExwz+X9Ba/7o9fCNbkorIceCmPX4ZOJ27/BRwdajeFLirMM/9a5LJcNBjW6UpzWaT4ydOoJTq7jeqldn/tFwuMzMz0911SQRGalXq9TrHjp1gY2ONZrNBuxkZ/rtjhECn3baBSD0WTiYUHEcsP1u6NuusDN0o1p5g6zFnnG5OGqUzJ+7giMn8e1YP5Hncikaj0Q1E0tqwTboBR1qzsbHBxMQEa2trBEHAiRMnaDabNBp1XNejUqnYCcTUF0URpVKJ06dPs7CQX0DdjjiJKZfLtJpNxHEMpRNBHCHqdPjmJOEXA0Oh/PnUcM7X1tdRSYLvxYjjAQ6eC9px8TyPF198gYmJUaamp6iUy0RRG6VS2u0OHjGJrjM+cxJNlY16wzwfsrnVOsKBjSs3qB4/BrmJFowpLEnNJi2OeJw6MUVpZIIoAYe8E1kxDHbkuVuGwEeAZa319+SO/x/Aktb6x0TkA8Ck1voficjXAd+FYRR8CfCTWusv3q6Ngud+b2Cee3ejED2A534YY3vOdfX/XB0BTOBNKfQ5fuIEPaaz1ZAlM64YIVCvb1Crjhj6o+uwvrFOpx3RbDZtJGvaFcxJstmZZ+/BCm2xaQyM0y7PHdfKRr06vbJitVRxuikogc30SZ1tBtL9rC1H/XbHX61WxRGh3jDCLkkSfN8n8H0adtPuVstkeKxWqrTaLUqlEo44uK7L0vIyc7MzXTONOA4bGxvU6/XbnnU/oySbCFybXiCOY6amprrMmnarRapSojjiV8sVHvvzv+DL3/LfoBC0SnlcGQeu73kkaUocJ9y8eZ1SGLK+vs7c7AxhpUIaJ6jWLZ5+8TpvevObSCNlfCA5umnGmFH1DqqxTunkMdLU+EUy1X1paYmpqWlKpQoXL1whTdqcOXvCUDft38D3jakq49u/8MILtFqDee7DCPe3AH8CfI6e+/YfY2yTHwfOAJeAt2utl+0P5t8BX42hi71ba/0X27VRCPd7D/NH3YFdYgvhfuBj+2RY0u85cY4wUFZOSsby65oU0jTBc72ccId6o06tWrW2Xo0X+Dz//At0OjFhGHDs2BzLy8u4jsn/osGEpPcxWzzfx+2jNfabUDJNOutPRt/s8uSzMPrsueX+J3cf5K6zz5dqtcrK8jK+1ZIFM1n5nke5XKbdbiPWXKOVwnGME7ZWq9lkaB5LSyu4bkC7EzE5OcHy8q2Bz1pEmJszzyWKIkSEs2fPEvgBnm/y91y6dIlXvepVBEHA2toq9XrdRoea51yp1njSERwc/MDj85//PFEU43sm+Gp8rMaZk3NotYFOUlSacGs94crNVXRq8u474vKGL3w92ZDLdry6fPkyaapZWbrJl37Zl9GJIqOR5xzRGUvIcV2efuop4+CtVChXyjz79LO8/g2v7yZKS9OU8+fP02q19ibcDwOFcL83MM+9y3EfJNwPA7Our/8nb4xTp0ZxHcsL15DEMRMTE6yurppw/HIFjbb2ZodGo26Ekushjgm4OX/hIvWNxqb6XUeYnZ3lxo0bVnt2GKnV2NhY79rMPRt01HV2WluBm9njgdQKOOlmjTFSWyll7fM93n1PO6abdyZbeWQ7ImX3mljeej4dguva5GeCTfNrolQdMZNQu9NhdnaGwPeZnp5BHIc/+uM/AlzGRkdYW1u97TnntfaRkRE2NjbM85+dxfd8KtUKURR1mTZJktBqGT/HyGiNj9dqfGOjxZNi7t/1fBYWFhgZCQmDMp1OzNzsLPVGi6mpSRZvXmV1fZ1SWGJ9o0WtVmJ2bo5adZRmq2VMYnGCRneFu+M41OsNNtbX0Ghe97rX8Zd/9Rlq1RpR1OmmWq5Wq8xMz7K0vMT4+Kj9u7n4vk+1WuXixYscO3aM8xfO02q2igjVAneO+aPuwL0IrQiChIWFBcqlMlEnQmESQd28uYjrGafk0vJyN/kVCMePH6fRqHP16jWOHZujNlJjbHSMer2xyYWrNFy7fgOAwEavrq6t5lYFirGxcURMit9NEZg6481bTT9VOJ7bzRujle7SKtvtNo51oLqOSxj6xrwSBF2ao9lub5EoMrtOfdGb38zKygovvvAirXabarXC1NQ0kxMTeJ7P+fMvkcQxURQxMjLC2to6lUoZL015+eVLjIzUWF1bI4lTQr8E9FhDtz1mrTl27BitZotGs7HpeJzEpGlKqVSi3WqROI6JNi2XiKMOUdzh7XVFo16nPD5Cu76GVEaZmBhBIyRRgqcibi7eIEpTUDF+3IJIURlx6ZQDOlFEpxWRJquIOGbbwySm0+6gNbRbTRzXoRSWCHyPeqPB0vIyszZDptYpMzPT1sSmuHnzGo1mE88TfDfA9Y1Wf/XqVVzX5crly1TLFRobt5unMhSae4FdYf6oO7BHHJXmfiLw9XccmzPUOAHjbzRLfBPR6GLM5D0evDHbOF1BnFj7etSJuHHzRpdGl4frOriAH4bESUIUmYRbaZoyOjaG73nUN9YJg4AgDAmCgHX7vVwpMz42huO4pEnaTbxVLpVpNJs4juC6Hk8/8wxaw6tf/SpDDFSKKI7wbe6WJI4JwsBQ92xa4fX1DY4dO2ZZP2I3BFG5rfaEp595lhMnjjMxMcGFCxcZGRkhijpdP8H42JjNKa+5cPFlyuUKzQEJswblYZmamjKBZKFNxmW373v2uWepjJRwxSWKEgLf4ddDh5KOubjY4cxshcW2Zn29xexIwNJGxHjNY6WZMjoS4nbalCtVREXcihxazQ7Vaomp6Wk21htgtyFsd9rEcWL2plWKoFRitFYj1Qrf9Wm3O4gjrK+vMT093TVpZXb1IAhJ4ohOHFMpl2i3Oriuw8rKCpMT41y9dp0ojguzTIG9Y/6oO3CHOCrhfjIM9ftPnbQslyxJmDV+dO3ThlMNuXwwkHETuw5AxxGCUshn/upzubKmHR+ND6RhCZWaPCsAk6NjJCjCIGRiYryboz2z8ebbNMlhrFs1Y+A4TjdJ1wsvvgTAQw89RJBtpG2drlr17w8r3Fq6xamTp2h32rRaPUcp9OzySmnKlTL1et1y8oVLly4xNjZOtVqlE3VAa0ZGRromnVRpnnnmmU3PeWxsjLW1tU3HZmZmDMW0Usb3fUaq1S57RRyXS1cucu7MOX4+ycxVJhoYcVA6xRUPz3O5tfA8K2sRj7z+1USxIKTm76VV11Hql8o8+8xTHDs+R6VUMymUzcO1sQ3WoUov/iBL30CXhWSDlrq+j0w290KYBM3i4iInT5xkbX2N6zduEkXRwLE9TPqBAgUK7BGu6zA1XmO0XKJc8vBshKrneIjj4nkBIiYrYuZQ6wlfbcPjU+I4Nul6220ee+xRgtC3AkFz4uQJyqFHC5MW1nHMb933fRp1Y7vfWF8Hbcw0cS6aNKPndVk2urezktLG2SuOS6lUJgxDAM6fP4/juvhBYDNAmklCaeN41UCSJszMzNC0+dQzdkvGKVdZVkeVdtP3RlbjP3P2LOPj43i+x+TkFOVymZs3bxoTSxxz4cIFzpw5s+k5r62tMTIysmmCaTQaJihKK8ph0PVdOHaTkCy9gWCiV5UNXEp1ilKap559hhuXz5MqTQzcuvwyjjJxCOZvJCAOWhwcsNkuK4CJR8DGJIjSNtWAnbStoEdrVJp27elZps0sstdzXVzHxc2OO0K5XGFubg7f92g1G9ty3gubewHgdkfpfN97gb2h3Wrz4jOfI4qgk0IYCO1IMzczQ2l0hFj1knBl9ENttTextEXX87raXRKnhCWPwA8YHxtjaWmZG9eugWM21xABP/DRgOd6pE7K2PgY4+PjAN0I0Ww1kOWGyc6ZTSdMgI1JPSA8+9xzm0weWmueeuppHMfhNY89ZtIr6M2rgCAIWFpaZnx8zLaVpTMw2rpYbd91jZ8gTVPGx8cJgpBLCwucPnWKTtRBBGq1EarVmkkwlpr0vJcuXeLBBx/k/Pnz3WedOVEBHnroQa5evYpSit+cmOSdWqEVxCrmSask/3Uxk0yaOYitfnzppZfwxKXqw1jNZXkdIKbVipn0NE7aS7+MSkErfLcEjp0MtXVaW1pUtn2hxvgrtNK9XPxirsn2KO86qyE3BrDPXeG6Jse858bMzczSbF/ecuzdFcL9GkWk5FFjnuJ5HwTWPfh/RoyxvZOYbI6J9vnuapmOShHppc/NKIaGQ2409+xXntfQOu0Ox+ZmSVPFSLWGFgfPETzf49q160brd03QjwY6UQfPcW1UqAly0lrTbDZYXl5BHMdw55MUP/A5NjcHWpEkKWG51O1fHplJ6PyFC5w8cQJthXumZfq+z/j4GK5NsZumSY+p0zUJmRwsaEyAUxyjtWZmepqXzp9nYmKC5eUVZmemKZXKvJQT5GBWEK9//etZXl5mfX0dMKaYW4uLXLl8mVqtxuTUJO/UmseVtiH8Ct+BxevXuxOYdA0YGoVQq1TxXJeRcsTGWpMwHCWQJo1OwuKNa4xOzKAc42hGC1fPv8TsyZPm72f/ZlevXUOlCSiNKE1YLjF3/LjZOSlNiOOIMAiYmJgyaQkyC5eNRehRV23UqghhEKJUytLSLU6eOMmzL7xgIpC3wF0h3AscPuZ3UW7YsgUGQxyjjXuuiyDEEZln1QgcGxSUqizVbzcevctiEavCSbYlHZLTsB1rClGMjY9TLpW4evUqnh8wNTmJ0grXMxqy1pCmpvJyucIDD4zTiSLQgjiGHlny4drCAuL7lCtnBt1R1yRUCg2LRawjOFUarWIWFxeZmJgkTWPQUKvViKNoU+Rrmqa0W22qtSpJkhDFMY5NQlapVFhdXWVycpzr129QLpcYHR1lY2Nj00Tzuc99jjAMOXf2LFoZfvjvHT9GkuW4z3wWIijM+8byTabGa3x4eZUfAbTdYMRMoCnTc8dYXbmJh8atTRKUKszWRhirjfLy85+nMjtDK7GCV8HJkydZrm8YG7ylLR6fO4bjCWEYcvHiRTbabZqXLjA7PUdjpcHZB85Q32iwsbpCWK3gej5JklArlRHXIY5TPM+Ya7QV7mmSsnjzJidPnmJtbY2Tp06zuLi45bgrhPsrCPOHfF0BA61AO4DWJGlMp2M1Rp1paIZ66HqedbYpXNezOcXFBiZZu7ZN/5ukMaKyvC9i2STGzr6wcLm7R+rS0hLlchnPdbrmkFRnqQ6EublZGssriDh4vtHury4uUZs4Ttpepd1q4nmOyUrZuyPAXF+r1VhfX7eUSQjDgEazSbvTIYojs3mHtTm0Ox3yWSYFc29ZFGiaJDTaZuOPyelp1lYdkths7RdFbncf0cwnYPLpKJI44ueS2CxybAAQZAFb9ExBjgkYajfrIOZZfMzz8BxsH83fKgFGyrC6GlE9PoYg+I7QijrEyuHWtSvUpk+j0TgOhNWQjatX0GEA4ljzWkoaJyxuNBgdnaDdvonvedxaWWZmepJnn3meY8dnCcplWs0G1ZFRxBE2Nta5fPWaYdWMZNkt1zl2/DhaCzMzM7ieT6cToUi7ufEHoRDuryDMUwjqo4AJ08duQg2uK+C46DTt5nvBblKdhfkrZYRNJrRNcKthmihrw87Ou66H63okScLLly4BvU21kyRhfWMDAaanJrsOT2xkahLHNBp1tAY/8AztURTLi9cIA5f19jKjtSpxokhSZQWlSYjlBz7NVtOaT5bYWFujmkIS+mgtLC0vdyMw0zQ1KxfJJiLBcU3OlzhOCEshqyurTEyMMzU9TakUAsKtW4tEcUK15qPj3i5NrmPMVlk07VcuLPAfT50ypiQbINXdflCD67ugwXc1IyOjrDda1t5tJoCMvaLFxRFFIBGl0w/TSRSIccoiwkOvfi3XXvosqd1QJfQc4iQiScALLftFQDsOpCm1kSqdVhvHdTh+/AQrKyukqTKbdJfKCJCsxVxaucSxY8colUJGR2vURsdwXUOlbDSbJu2E46G0IklNhOrs7CxLt5a3HHeFcL9LME8heO9baLPDUasNlZLRIlOVoxoam4ARPn5gAoswmR8dCa1HTdPpREYQKeOYNLZ4x5g6NIa9Yh15Joe8qXZiYpJms4FntfnMmel5HoHvUi6ViKKYVCk6nZhOnFCplGi1WrilMiCIm4LVvB0/II4iSmGJTqvFlUYDxxGq1Rorq6tMhDVKNjir0Wrx0+0O77B5UUphyWwMHUXEHWN+0SrFcaBSKbGxsc7GhrGfa60ZGx/H95Pcbk12FQR4HrieyRHvuh5r6xu4rtn31fVMFKyI2JkxwXc9XBUxNjnJzVvn0eWAJIkRu0LSymTRlCRiaaXFWMXk3UmTxEymWtFsN9nowKzv04kSms0mKo0IAyHRijiK8PwAlSpanTatWxuUqhUmxifQQBxF+J7HA+fOcmnhCsePz9Fpdzh96jQrq6t4Yy5jY2N4dmPyNEkol0PiKEK7mltLN5mdO87oaG1gvEMedwXPXbZI+Tt/yP14pWL+qDtwCDgqnnvJF316QlACWgmuI7TSgPePnUChcMUhvy1DxmfW2m7oIL186Vr3bPdZwFOnE5GqBEfMbk5XrtygxyM3wt/zfMbGRhDsVnSW9pgmMXEc4bo+WsPxkydoNBuoJEYlKdeuX2dyarq7DR2WYROnJkiqXC4xOTmJa1PR1iplrly6wtzx40RpYlYHvjE1uXYjDs/1SFLD0Ik6EVEcdbNHiphNucV1SCKT2jYIQ5IkZX1tlWq12mUQdXPfKEWSpt1c+UppPM/coyPCR+2+qdlqpqzqxE7I6uINmp7PybmTxqeRBVVpKCU3ScIZ0tTw/jWGIooWFCnlUpmr519g/PgpVi9fpFwKCcamuLp8i1PHTuA6ZtW0vrZGpVRGCzQ26oShT73RBIFypWr4/Rt1XK1Z2VhHKc1IrYrnefilEq7jsbh4g9HREYKgxMrKChMTk9y4eYMwCAnCkMXFxS3HdqG5HyDm+977P++lrr2e7y+3134U2D0yO3Oaaqu9xYYih2PNJDYQyNqIs/zhjrhkZhiju5t0AJ1O1LXDZ8m4Uklw3aDbZo+2qDh2fI5yWGJp6SaCS6JjHGtqCDwfx/XRqWLh5YuMT05S31gnjjq8/vVv5Oq1K3Q6Ca44pBj+epLEPJ7E+G34jsVFHHHoxDE/ltm4L13MbrxL6du8i2y3l6RJwveOj+HYFYe21ELQBEHI8ePHeVyltKcmuvdkolc9u7GH7rJ9vjmJWbp1i18pVXqZMNttG+nrkCYxjVaLtusQjExR8j3r9FVsbGzQaDZw0g5r9Tql8XFcV7qMpSyyFqCeNEjiBEkiqqUycdymVKkhy4ssLS2zsb7O5OQkpTAkKAVcurRAKQyolkZQGw1m5mbwg5AbN6/jOT5RHCHicOLkHCqJjc/AcfAcn5nZGdrNDibDZoUkTThx8oThv7sOy8uFWeZIMb/F52GuGVS+v77tvm93bYHDQbaBtOvaQBZHSNIYR2zAkVLdDZnNBtWAaBxXmbzsSuG5jgmeQeOKxnPEpC4QlyQ1wTdxHNGl2eSE6cLLl9DA8bkpPEd3g2s6EeCA5zukAj4h1VKZtZU1SkHIRn0DcYTADygFPvVGm1QnBJ5HyTGbWDyuFJCSasU3dqJN993d9s/pRbxq4KOOmbTeieb43BygbIIzj49aXwE4fJvn8y+v3UArRW2kxjcnCY8rTZKkaJ05QFV34vg3IrhBmbjdspkwDeMkCw5yRNhoQLlWod1u0mm00kYAmAAAIABJREFULE/esFpuLS3jeS4iVW5dvczZM2dwPNfuj2pz31sN3y3XoL3GyOwUNxauUG/UAWFqepr1jQ3GJ8dpNFq044jZY8e4ceM6k66H0ppOu83y0ipJGjN1fIblxRtUq1WWV1Ypl0qUvYBSaM1ibkCpCuCyvHiLSqXC8vIKUSfixMnj2467wixzQJg/pLrmd9HWsOXuRxylWebMpIOyvHWlQVHhXeVJwAh1rJPRcQTXmk20ztLsKsOdtpGkyob8G+esY/O4gyFKmz1XjdNNo/FM8JBKaTdbVKvGvu37nmG4uD6e63H6zFmSVAGKVGnarSYrK6to4NWvepRLF18kUYo0NhGdT0Avfzx2KhGh0Y42bcdHdi4L0rLMn57pSfGBuVlUmphNQiw/PjPRPOl6vBOz8ul0Ot2slq6NMM146ojwEewKQRvt33VMdk0ydo6GwBNcNMv1GNGxWSXY9ABhqczy8iqeY0wxjWaTc2fP2jvI6KbZnrKGvnrr0nlOHJvg+vIG43OnuLF4FdfxGB8bx/NCWq0GtVoNR4Q4jmm22vjWz7G6sk4Q+iwtL3P27FlevnSJSqVKp9NCxKFcDpmemsVzHBauXOX48WO02k18z7fUVdOXm4uLRNHg3DKF5r7PmH+FtFlgNxB0qrLsugS+i++5aIwtWKPxXSPUUmXodWmqejvuqIQkjQg8B99zCIIScSJ0ooSoE/UCnRwhDMr4jhAEglgnoFKp2XAiSQhLZUBTqdWo15sEHrTbba5cvsjUxBQjYxOUy1UCL6Cxscbq4jXOjU8T16r8k/PPo4Wu8HUcp0vn1Fpl0tX0efNb9zlgWSdg0/86rnVkWuGvQMQ1jBpX+JjnAxpd9sx7FuzVF3YvmFQP7VbbbkvYO65xEEebSFIPUhXhirblzGpIKUWcxATl0LCCENJUmxWAVmgdGxqmdWarVDE2M0envUEcpzRbTUCYnprmyuUrJEnKQ2fOEDgeaRxTwmWl2WS51cQPApI0Ybw0zrlz57h06RJJkpoUEQIPPvAA6+tmQ5IgCKg36qysLlMtV7uso4wS2t2ndQAK4b7PmOfghO1B1VvgYKG1wjVZpHAcDzDatRFuJod5kiTWzq4JfQcJhCQyuwThupRKNRzHI1GKVmToj2Ho43g+jkg3X7jW0GqbPUK1Sru5XBKlKPsOgcSkKsENAsKZKZob6ziOcOr0GS6/vEArMXutuo4wOjJBHLWIay4u8G7t8PM6xekmuMr47manE9e1k1Vm71dmL9dM+zUmKcfa1O0xq4E+6fQcn2iNtpz/HqfefMoSj2WTYu8hm7o83/3/2zvXWNuyrK7/xpxrrf3e53XfdW9VdzXdBlSeHYRojCFoDDEaEwztqxs0IcgXDBoDMdFr4gcxxhADoemI2CDaIKCQjoYQHjEmBpRHI9gUVV2pe2+97vO89tl7r8ec0w9jzrX3uXVuV3XVvffcqlr/5GS/11x77XnGHHOM//gPlS6O3aVElIpJCAQjLOYHQNaaxHahiOdhshx8GY2mj2uVSjZYY8AKAU8wBucd927OOf/0JWaLCu8d93bvURQ5TeOYlUcc3LrJmbM73L23y3K55OzONk3jaFxDtVzy0t275FnBaJgr+6hWLaGNzSnBOxoXuHzpIhBUcjk1PBGDi3TZB+GJDsvAk2vQrtJJJrybcLpsmci2MIAUOG8Zn7nI33INTRNU+RDTartILPzxMVnovWvL0oPziNXinTy3bbl7CpA0Ta2KhkYbZGsfVR853FqBqjTIHjZT2uB8vlB5gGgMPw18wgi9/oCNxRHBN/Se+TBXX7qGr6uozOjaqlljtEBqUTWxcbdvjWUrThZWDbVDpHAiMeYezz8xfJIxCEgbfuE+DzUVJ60/RsAEELvSdkm7DOfBiufll15ivL2DiXH+FMrJix53796jyHMQzYkgMOz36fX7TEdjxGquwDVajBacZ++VG0y2hvQ3L3DtletcvHCe0Ah5XtB4z9Gd1yim2yAW7xqCESQIVn9xmqrCRIPtfUMdE8GTze3IlAoczY8YjoaEuHAm5izAy6++RlmW786wzFWeTIN59b77V098V4f3O0JSEojxZiOquni49PyosXzCe2wxguBbLXfvPVmhCozBO8TkpAYb3joa5zEmp6pU4xxSFaa+JgEWTUWW2dgVySBBuyFZybGFoa5riryH5EK+kVNXNdpOD77LAM6zWNRcPTziXzz7EWxmkKCl9T7x672P/rPmB1aJ05VXrUZYi65ckgVOFBofKKua6XSiHZ0IrcF1XnMNIR0jKF0x4ZhhZ+XZOwnYaNgJxO5SIJlgAkyKbK0ILIaR4qLnvCdIzGm4hqcuX9FrT+BosUT0rWTG0M8LxNQcmMDBwZzJTtTfd575/hFNP6ef52xOh8y9w7sqqjzGnVYKlw3ydhdH6NET3b0sfA1BsNZQDAc4Sfr3a8vcm/jlT7xxh854dnj3QoTY/1hN3mJZa5zZeQIZPyGGj3sPRgBDQAtpXPTcjTW4ZhVe8T6sGl5ITGcmCqUPrUtbFEqLTJrizjm8C3gc4hw+OEKppeshqOCXGKOG0QgmEza2h3zVRz7E7O4dxk1xLJ4eok5LQOPPyQPW51Y89Hh6eh2SzgtCMPr+0WiAi3oyy+WSoigoigKLFgVJMKgKeryea9dW7XLaIeh3DT7gaSjLkr3dPfKiIM9yil7GeDSAoMyXmkAWzy/JLUvK9PqAkYyeyRDvCEawsckHUd++Ek91uE8DNDUcHexhguAQRpvbBLR7k/TGFI3H04trmtfjkSFGWwpqtW9GHmsCgg80AS2oinPIGG3q0v4Ea5IUD8K7wrjDk23gr/LknluHU0ZYuyMZ+WBEvVwyGfSomwqRjE8tlvydmCBLHmWItEfnYmgjMkMkGlZlb6yHXQwms+BopYNJUgMCRZFHI6vebxZFx+LLgO4ojAihUS33O/N7/IW7B3z2mSvYXoEHfHDR4EirT5N4McmxXpcQ1rBN4vDrfQ+IBwmiDBUrTCdT+r0iauoIwWryVcv+0yUMtMG19o605E9nQOaaLB0EkPGQLM+1SXiWY1ylSWZJi54eJ+0yjLHgnZaSidAAJi/02K6hrioWB3uUTc3BfEHu4dKl80w2t7l57Q9x3kT9eMEEy507d9m5cAVjQbxeHG+krUgOQcXbQux8lZhEPgSsCHVVIUbj/V4vfnttj/1wD0DXrOMh4eppn0CHJxJqogUXhMY77uzuk1k4mh3x4heu0c8z+kVBnhcMBgMGgz7D4ZDhcEB/MIjNJTSJaIyh6EfP1lpslresFWsFI0KR51pmbzKyLCfPC4qswNo8atAYjNFQCWiTClBDbK1VHrcxBKvVpHm/4Jteug5e9xVGbExq0kY10s6gjaejuQMV+Fp5myvKZogUxMCZzU12ppsYF8i8YMqGen/G8vYuWQCX3n8fCycdL6w9Jz7AqIcbDmEyorexQT4aQVHQCCwO96i8x7tVFyRjjBYNSQwmxaSuCRVHN6+x98qL9ApNrmaZIfNHbA8sH/7QlzEpDJPNDQ6OjpgvAkOjmjsETwYUozHOa19asapKmc7VOdfe9z7Q1I3u5oKyccQYirjYSTxHlY8Q5vO5yjknGYoH4F1l3K+e9gmcgKt0VZ8dHgyPMCsth6WwN4etoQXfMNu9zUbfcPP6i7jG8amqZLlcMp/PtaP9Ykm5XOKaJjIkNOZeVxWuaXCuiS3hJPLitdmHR7sbeTwuFkSJWnOMlajnniGo8fUa+kbzzWtsFx/4r1tTfm46xeP55msv6fsiA0fd5aiPg7TxcB+C9nxN/nSgNVjJRkvkoqfwSCXg8gyXWcKgR7Yxob+zSe2dUi1bzj/tMYG4o4mxfWIqNqD5CxFGwyGT6ZStrS0GgwG7ezPOPXUFJOj1rRrEWvK8iJ2hNLavqu6GuQ8Mdy5weLQktzmZaAK7XC6gKsF7dl/+Aue2J1x+5rLqrce8xHx2SH801eI0LMGtuP5aUBUlIJzDx45QVV1FLr+0Xrmxpg1nOae/93A0Is970ft/8Nx707CMiPSB/wH04vt/NoTwT0Xkg8BngG3gt4G/HUKoRKQH/ATwdcBd4NtCCC+96X/BW8TV+25PC1fvu+3w7sPjmNsBQ2nHyuXOAkGWuCDUYjlz4TzlwV67Hf8P1hICfNz7NX51Ykfof7sn0DQ11uq/bvCaMG3lC4Cs0CRg6tnqVZISMRlFL6dpakyWKV9aVNTMx1i4Fct/297CL5Z84s4egZpqUWOirniQVRhELbaseehhjSVDjGcno77qwpTaAPqgDUV6vR5GiM9r/sAYiaJqK9nedEXTWCnsk54XDOPxCGtsS28ENaBZlvOBP/lV4OFPXHyKz/3u56irShPJRphMphr28Rrjl+CZZBm7r9zg0uWL7N+8RfANZbBMC6j2X2NjYgmSceul56mqBmcyXWi9Z3awy3Q4xEhAXGyz1BZBaThN4nWw1kYNHaXD1nXTyj1LYguth/cQXRzXdzQnze83o0KKzqpRCGEmIjnwP4HvAb4X+PkQwmdE5JPA50IIPyIi3w18ZQjhu0TkY8BfDSF825uM8Y75mFff6QEeEq6e9gl0OBEnUSEfx9zOrA2T6YgQDJkYptkC5zP8YEJdVfTw0BtgbLbmea7CFgT4DmHFHWc9BB2gDZGElmrYdj0iqJcejyXJIDpPJoLF4KoKV1YY78gBL2AySz7sc9jU1MEgmaE/GPEDr75GcK4NWPu4oxAj1M5RN0rZzGJjEBM5/Cq9YNq+qdpyT+mSly9fVnliQquGmVrQNU2jjUxQW22jZPDaL8h6nCZEdsxgMKKqKuZHR1GDJ5Blll6eI9bgXMPRbEZdVTSuIQQYjUbs7e1jxGBMwAqMrKOqPftLRx1Ww40yqBt49kNPE7KCqq4Z9MY89/wf8MwzTzMgx2eBRemwQGahrNcMuxFNqoeoKxQX5ZayGquPjU0ib4kRFRk5axTTl1955e1TIYMeZRYf5vEvAN8E/I34/KdRu/YjwF9hZeN+FvghEZHwiAn1V9/k8eMYs8O7C49jbqsaorJQgvgYTxXyLOf1V15jZ9qnN5i0XreJfHTQhCMCP84a9dAI394yU9S7B2KMW41hnlnEQ24MLEtcWULd8NQf/wrc4QF3X30VGfTwvT5LC3U/p2ksVVWRG0NuMz5jckabU5blEVnexxqLC1pJ6lO1rUT2h9OOR8mYa+gn9QhVi5gMu35s1SQblPaYdgLBeQ1bt/F8VrH9+Elpb9+I69evMZmO6BU9sjxTPrlo84zSeaTR5PTdu7v0+jlFrgVHvk1U67WsnGPn7EWaozlucQfEsDEds7W9hUE4vHmdJlhCHcizXjTEFt8Ebt17mXy8TZ5nGuCxgSxW2mr+BLxz7W4r6d6kIq71BDqJaSW606ENUSVd/Aeb1bfElhFt9PhbwJcBPwx8AdgLSb0HXgaeivefAm4AhBAaEdkHdoA79x3zO4HvfCvjvx1c5e0Z3/s/d/UBtx3eG3jUc1v/QYdgDRIagncUgynOWJ56+hK3X36V3oZfM4JrSbLkskKrz55Jxr8X+HZRVck+Bus9pmrwywU0tRpOgVKEfDIm35yCsfzD557jH5w/Tzh7lr29fT4526UqSz4edNH4SWOxRjCV5cJ0QpbnbI/Os5wfMciVCpmomM45xBDDOmFl1KPnmUIzSY9FooFNSIY/0RlZ82rV8NGGcVJYhzXDrpdnFXoK0XDmec5kvKG/g5GoGqnhI4sHMQTnKHKNey+XJf1+X+mHjcNYZSiNJyMwGVvbO0wmE+qmxjtHtSwZFgWuiY1LJBB8Q1PrmRlrIMtjsxFNCVTlEVXw2MxgbaY5lBh/D/FapLj6eugGkVXyutVuFyQa/5YK+wC8JeMeQnDAV4vIJvBfgC8/6W3t6A9+bf2YnwI+BQ8nLHM/rj7kYzyM43V48vCo57a1NgRxqhkToHKOfGhwrqYpSxoPdVmT94tUT6NhC9ToaRxcy+KD87hlyXdUNdQVuTU0TU0jUIzH9M7tsAweF3kSGeoVN96DV4MZvKNuGn5odogRQ1Hk/FRsTZeJ4OslwVguXnqK26+9RuY9i6MZrx7OlM2ZQi0GTcoGNbHr55489RSKUS8+hnBY5Q8g0O8XHM4OGY/HNE1ssJ0bbYe3XEaP/XjoZUXD1Ndab96nWLxpF0gx0nrkAdV/DwZcAOO1araua7I8xxjVj3ex9aE1gmtqvA8UeQ/Ti7TExjEej+hllqp2+CB4q/mPzOacOXeBslaN/eCVOlr08rhICSZ2wCI2B9FFU/u45jbTRHJMWARCu4sRiUwkq0qVb4YvieceQtgTkV8HvgHYFJEsejiXgVfj214GrgAvi0gGbAAPFh1+iLj6gNsv9fMd3n94pHN7WSI0kd5msXnOzmjMjet3ufDMU5SLiiLLNDzhPUXd4MsKcdqWL4TAx/E4gU8XBYz7/LgZKoUuBOW3h4Avy7Z/J8TYdaRQfjsqZdA02tXImlXFo7WWFA4Qo4nTV156kel0g73FAlv0uHJliy/80fNrre1WHncKqYiYthGHcsNVoqCJ7QS1Wta2j50PLJdLekWfpnbYzFKVFRsbU5ZlGSs5VwnTtLauomCRT7/m9bZYC8fL2vt0gQvtziF5yU3dYNtFKLCYz9nf38cHz3Qy4czZs+R5jnOevYNDDveOqKvr4B2Vc2xsbtOzgcIGnDdoJ8LYRjEk/g0xdKaLk/LXffvtmrrWqtW81xYptZ69SR24BKJhT2GaB+GtsGXOAnWc/APgm4EfAH4N+FaUVfAJ4BfiR34xPv5f8fVffdTx9oSrD7j/pX7+7Xy2w7sPj2Nuh+CZ9gOFUe+sagI3XryhnZkCfGTomWQ5zJf4EHDGUFsDgz4OjxcAwyeJRgz4FFG7xVgEH724yFDxkKxa2481BP6tV7Gqf3XntnrgMSRgWskA1PBawQTB9gbcPThgPB63NDyfGDtJsyas4t5K06MNNyQCempMLSKY6N6vDKl+B41XawglyzNms6NIB5T0hdavaJtQ1NBzIHiOMXA0UP3GxGvy+vV3WUtSh8BoPGY+PyKxPAfDIRc2NtojuMZR+pLGeWazGXMvzGcVH3zmCpNeD1+WNNU9bt25R/BCUztKVzHKM87tTLCxcbjYmExtGnzwFHlPO115R5HlBHS3oBE5jcU3rqFe1hRFgRjdVRhj9NJ8EaL7W/HcLwKfjrFJA/xMCOGzIvL/gM+IyD8Hfgf4sfj+HwN+UkReQL2aj72FMTp0OA088rktYnhlt+bp7QzEUDvHmTMjFgczil4f6Qlzb2i8497dPXbOnFnRHr1gY8w1VWoqy0QZKj7qkRP135OnnpKbbdWjxkIApS2qp5483pWhc67WGK8RXGyTt3tvl83tLW7f0qYZEM2tT9z11j2GkJqAm7adn8bok+FdKUm2/rjXBayNQcfK3FYkK75x3TM/aTldy92y7uGnitz196VdyipkFKiqiuTj+9Tf9thndedweDjjaD4nzy1FoZWvrnFIVnDx6SvM7ikFcrG7y/kPfpC7e/u88OKrDAcFRjzLZcOZMxts7ZxhWTvKeqkyykHwTaN5jHZXFQg48thwRDX/C6qqpGkceZ7y/yfjrbBlfg/4mhOefxH4+hOeXwJ/7c2O26HDaeNxzW0vwrw2mFC3AlqYnKPZnFm5YPvMRYwRzpw7y+HhjEG/j1gVvGqi+mIqLBIjsQhSE24hxo2lNYYSOz25tcYZxLDISj8lMTLi99IknzHKiAnQ6/cZTyY0dcPe/p5WRxqJLBxLE5Ly4ypEE0TITKbx48jRN8a0YyRv3aHnkBg3JoZuer0eXnwbPjFicKgnvuLKr9MfQ7sLSbuE4xup417tupOrSc2sDVu5pmnDJGIEm0UZiJASsnrcw8N9IFDXMbQUfFsJOhwMmGcHyGiMm8+5e/0avQvnOVNcoDcaUGQ5d16/wb3dfarlnPMXLjGd9Ni/t8e9wyP6002s7bVNOWazGUWu7fSyWLRUVhV13dDv9+IC9Q7ZMh06dHj7CCEw3LmIc7VysYOnN9Qy/8zmNE2DtQYxMBoN1QN2Kx2V1E1p3VYpT0QpcokfLiLRS14ZUvWIlWxhRQhi2+IY4meNtRC1TyR63P3+gJuvv6788KIgyzPu3buHR41xEkMD2sRpCFodm2DaczArTneELgrSFmBZa2PziRhRicY8FT8B7SK3zv1uQy6EtRh2QCWUV9d/dX/1MR9iE3IjVHWt5xeVOUNQZUj9DgZt5tTw7LMf4g+few5C4NKli6AbKXwIHM3nLJyj3tvHW4sfjhkZYXtnyOHBjP07hxzuLxjklsMjx/KVW7h6QS8TKi+YqqKfFQwHAxBhe2cb1zSUVUVZVRhjGQz6nDt3tuX837lzjKh1DJ1x79DhkUPY2z9gOp3w+muvQTAMB32KXoExlRq4YNqwxe7uPltbW6vYcmK6xFBCSoYmr9N73yo0Ase81/VKTmWRuLYy0sf2fSqtq+EcYhJv995dQAXMymZJVSauC7EQyRyLWScv2qwscWvwo/1u35tnebyvUgZJuTIlZhMShz89vVoo/FrsXA23iSEg51IjkFUC9g2GnRWHXIxE+maIap0NQeBwf49mPqMpl0zGAzZ3znDvcMbh7l02Rn28c8wP9tiYjhlkQnk0Y7FcYEMGodEQSpZz9+497t6s6A0GjDe2eepMxnK5pCorBMPZS1c4c3YHBKqyYrFYqnxD/M0HgwHD1JErJoPLsow6QZb7dyfr6Ix7hw6PHIG93V2OZrNoaRqqaoG1kPf6atyTtw1sb29R1w15rgqJyneG9D9+UhLNRyOeeOUrqmDUL2kNsRbQJO14UsRBlDaZGCNqlIUQXGSJaI/TEHnuaRFYHyjxzpXQkVrxSTuIygQrzVGMyh4cC6KkZCzSJlnTEKtY+aqL0/qlSJTJVZh8ZfxNUmJkFdZJC5L3gSzPKcuKIs8Qa/AiDIZDRsM+d+7c4fb+AlffxIuQNSV53qOqKqSqmO8vmPmMqvEs6pq8V1CWFVluObu9zXg8pNcfqNRCqXIHedZDJrprMdZydDTX3U8IGm5JIbewShSn3U/7e/vj1+EkdMa9Q4dHiBACw0EfQSiKPCbi+lRViY1eaN34+M/bUDdN2x/Tu4beoN8mCTX8EVguFgyGw5bGt+5FJ+86y7Tphb5uEQJ1XWOtoaxqQlAjHFzUnllLMq4LXCWPOaBsnySRqxWycmzRWJXF09odH3vCpuC87jakTVZmdtXEQ9k7q7Z8a1dxLTSzCsmsL2Brbz32XMoJpGMkDXTvfatz0+v1aBq3Wlx8QIJQ157pZAM/CvSGBa+88jrTDI5mJZPpmO3zl9g5e0ZZUGXFfFlqiCyAtYLNMoLRxii6yFj6AxP3SJov8ajaJkGfa5wusE2cB96zlrfwLR3y2LV+ADrj3qHDI0T6x8ys8pzxgapa4GPJe28wiJ6lYGxGXigboiobsNka80WNlIleZYKwCsMktklb4cjKCIhAr99jMV/E9/kopwt1U5PZjCzL2NzcYDgcUpYlvV6fpq6jZg1rxjfpjyfnPzWOSEaINuRxPHSzXpGpRraqKtWWicwejZs7gmPts8fDOscSoymclMZdg8TdjqTM7Qm/SwiBouhR1zVNU+PqGhc8g/GQre1NhqMx1ljKumY4nmpYKe+1PP79vX0Njwj08iIuzpoQtmIwJqdpqsTDIUhMlLuGLLeYsM708W2uJMts/B1DDM0dF5CDEHvWPhidce/Q4RFDROj1+0p1E9WV8Va9WOc9y0XZPm+sxZiM8XRKU9fs7++xubmtBwqhpTZrnH1FfVQj71dWUJL4Vk2e5TgX2N7Z4dXqNa5cuswrL73I9tmzONfgG0d1bxcZj7A2Y7mYxwIkE6mBaohTlyWCxBi5rNgy0fNOiwutp03Lddf4+qpptYioLnkI5FnGYrmkrpOxX9Eij+8IkphwWrg0sSuSNNrt+pXHWj2RpqlpmoYiLxgNh3z0o1+HMYaqrKjqis3NDbIso2nqGBIJFEVBWZbKcHKOLCvahLEnYDNdEM1av9peDCclwTQI8fusG2aV8k0hI/1pU05k9Z5jn5HVrizBufdIJ6YOHd6VCIF+kYFvMAacb3CVo9dTPRNrLZPxuE1ANrWjP+hROy2J39jYIESN8FSQlJKkPqCdi4xQFCoZW5VLjLWt7roR4fadW0ynU+7ePaRX9Lhz9w7DvoYiDg8PaFzD2Ejsj+qpqposs2pIg6imfGgV2hFrCLFYKoQUw06U+zVvfVUiujrntbCC914Lc0RYliXWWprGRY0XjUGn3KjauDUvPXJ1jNG4vos66947skyYTqf0+32qqqKqKppGG4KnvMZyucTaLDYZgX4Mf1lrV/1Vkfa6W5vdtwM4zsEXIYZS0nsj++iEXUPCuiE/niBeXcMvFn45rpD5RnTGvUOHR4hERdS2eJDnGU2tcrSj8ZgAHBweMB5P1PPr5SoSJlox6r3n3r27nD17Hh8cjffKM/eBWzdfp98boX6kZz5fsrW5wWg8IniHzTLG4wmv3XyN3b17bGxM2b23T15YJuMpi+Uc5xvyItOkn1guXLjIyzduYG2uBjwaFh8CRV60XrM3TmPogbYLE2iStGW9xFyBJlhdNMYrqVtjDLOjo1XfVGPJsrBiyYQG1xZL6bE0PKXx8e0z2+SZJkOrqmJjMuXs2XPxemc4ByEYsqxPnh83nlhIu4I8136zoU3IrgxsUrhMid5VmGt1m37nLFuNobce75O8wxuN9frn1+fL+u07Ke5/Uz33x4FHIRzWocM6wgl67o8DeWbD2Z1NiNWhiApSZbH7j4meJDHhVte1NkaOi4IR9aZnsxnT6SZGtHCGALZumN+6xdkPPMtBtcT7mmZ/zuDsNgGVmU186Nn+IbYwXLv2MoOhtuebTCcEoK6udWLXAAAJoUlEQVQrqqphPBhDgCIvWh68No9WrfZyWZKYJt4ntonG38uyBFgLSazi6yY2lRYxUfXRxwSt58s+9Kw2HhGJvHLbLgbz+ZyqrukVBYFA0cs5s3M2etZaRXt0NGM+X7C1tUWeqZFuK3cj1KCuiqpSAVeruMj9hnTdwK6YNWkbUdfNqso37kJOoluuG+907BTiSnmG4+O+EW9mnz//+c8zn89PnNud596hw6NE3NKH4MmsKj/aPGM+XzAajpRm7hwuMlWyLCNa1baCUxBGoyH7e3uMJxNsFpNyOWQCd65dY3L5KeYCVS5M8lwN4loh0Gg6oWkaJpMxy3KJNVBXNS6GblztsCMtYErSufPFojXeglCWSxI/fL0fqKxOlOTdJnc7y1Ti1gWv1bQx6WpEU6qpqUiSwQ3ead/RyNQZ9PvUTc3ly5djCCjx53U3NJ1sMB5PAWXlXL9+jX5/yObGJlmWHzPY93vfKdCkoZxsjVUT2vsr25ryC9I2GwcVAkuv6bVYxc1PCrukRG4SVUsL4TrjKeGkxeFLQWfcO3R4xGiaBgh48WRZQfCeXq+gbmqNYcdCGon6IUlKwAchE9NKAA9GA22RZ3p4PIKF8Qh3MGP3xg22nnka1x+SR0OVuO/ee1544XnA4H3D2bPnmc32NaG5LGPiVWWJg684PDzE2ozhaBAXCaVBpopOWVt4UuMILSxKEr/CuXPnOHf+HAf7h9y6fYvRaEi/P0BEuHHjehs7z/MeTV1TLkr2D/ZJBUpbW1v0ih79QZ/+YIBrUr/Y44YzLQTe627i8uWnEYE8L7h+/TpF0WNra7Nl4SQP/P5wSDK2mji1rbe/Hi9/A90TYrvD5JVrAjvLcv0do8bOSVg39mkBPsmAnxS6eavojHuHDo8J1lqcdy27whrTlsxHqSzyPKeJPTS9oNQ6q1RI17iVp2ctu7ux/+pwAAHKOxpXd9639LvEQ7985QrXXroGwK1bN+kPCpbLkrqqtdmGUwNujWFzc6Plx7cUTGM1yRrZKVpog8oQtAZeveHJZMrm1haHhzPKqqQoety8eas1VNrjVCv9F0czbt++pYnILMM7vQ4+OG7fusOHP/LHVMdFVl2LEpLH2+4u2iSmoSwrLl68qOGcPOfGyzeYjDcYDIZrnjmkpGlSn1QZBN8aerP2Gz3YyMbWeEYQWYVbtNetbd+z0vo5bsQfdNz1moO3g864d+jwGKChmdTJSKKWjMHF4ECe53gXqOpGE6lBPVLnHc55QvDUdU2v6EHQatZk1AiC847MWk3WzrXYJfjVMXZ3D4CV5+l9wNU1TbOi01VVxXA4jh68GtgQE6m9fkF/3sOjGuzGWq1cbVQkrCpLjFjECPv7B+wfHLTGXIhJxbWQdt00WCMczg7oD/sgWkw0HAyxmbJYnv3QR1guqxjq0MWmaVYGb72IC1Zeroua8s7pe6qq4fy5iyRu+NHRjNu373DhwgV6vX5s8B1pOUh7PA2RxRh+zJmk5PhxyuL6wqLHEbGr+oDIpinLkizLjnntJzFj7g/hrHv2b7WACTrj3qHDo0UA7xrd7ucaA27qJop1hZZqV5ZV9GiFsq61uCfP1FOOcXH1ggsMhtlsBgR8lAXo9wcE5yInO3ZBwtDEStetrQlZvkFdweuvv441hkVZt6epRsOwXC4Yj8eMp9M2npw8050zZ3FNw+HsgJs3b7OxsaHVl6wZHcKK4x49fPcAQzQcjdjY2m6LtJIxa5qoEOk9N2/e5tKlizjncb4ms6s4ejLsiYKYdg/GSPt91iEi1HVDUfTbxtzPP/9H7OycYTKZrjX0Psm7ph1DRGJ4zB4zwPdjXbExBCiKghTH1+Ite2yhuP9Y60Z//Xa9kviL4UlhyxwCz53S8Ge4rwfme3zc0xz7tMZ9JoRw9hTGPc253c2v98fYD5zbT4rn/lwI4aOnMbCI/J/TGPu0xj3NsU/zO58iTmVud/Pr/TP2g/DFxQk6dOjQocO7Ep1x79ChQ4f3IJ4U4/6p9+HY3Xd+f+D9eK277/wE4IlIqHbo0KFDh4eLJ8Vz79ChQ4cODxGdce/QoUOH9yBO3biLyF8UkedE5AUR+b6HfOx/JyK3ROT3157bFpFfFpHn4+1WfF5E5N/E8/g9EfnadzDuFRH5NRH5vIj8gYh8z2Mcuy8ivykin4tj/7P4/AdF5Dfi2D8tIkV8vhcfvxBf/8DbHTsez4rI74jIZx/nuE8aHuW8jsfv5nY3t7841ktbH/cfqqr8BeBZoAA+B3zFQzz+nwW+Fvj9tef+JfB98f73AT8Q738L8N/R+rpvAH7jHYx7EfjaeH8C/BHwFY9pbAHG8X4O/EY85s8AH4vPfxL4e/H+dwOfjPc/Bvz0O7zm3wv8R+Cz8fFjGfdJ+nvU87qb293cfkvnexqDrl2sbwR+ae3x9wPf/5DH+MB9/wDPARfXJupz8f6PAn/9pPc9hHP4BeDPP+6xgSHw28CfQqvnsvuvO/BLwDfG+1l8n7zN8S4DvwJ8E/DZ+M/4yMd90v4ex7yOx+3mdje3H/h32mGZp4Aba49fjs89SpwPIbwGEG/PPcpziVuyr0G9jMcydtw+/i5wC/hl1IvcCyE0Jxy/HTu+vg/svM2hfxD4RySJPT3O4xj3ScNpzGvo5vb9x39fz+3TNu4nKd+cFjfzoZ+LiIyBnwP+fgjh4HGNHUJwIYSvRr2Nrwe+/Isc/6GMLSJ/CbgVQvit9acf9bhPKJ6079bN7Xcw9rt1bp+2cX8ZuLL2+DLw6iMe86aIXASIt7cexbmISI5O/p8KIfz84xw7IYSwB/w6GpfcFJGkJbR+/Hbs+PoGcO9tDPengb8sIi8Bn0G3rz/4GMZ9EnEa8xq6uX3/8d/Xc/u0jfv/Bj4cs84Fmnz4xUc85i8Cn4j3P4HGDNPzH4/Z/W8A9tM280uFiAjwY8DnQwj/+jGPfVZENuP9AfDNwOeBXwO+9QFjp3P6VuBXQwwWfikIIXx/COFyCOED6O/4qyGEv/mox31CcRrzGrq5fdLY79+5/biD/CckKr4Fzbh/AfjHD/nY/wl4DajR1fTvorGvXwGej7fb8b0C/HA8j/8LfPQdjPtn0G3Y7wG/G/++5TGN/ZXA78Sxfx/4J/H5Z4HfBF4A/jPQi8/34+MX4uvPPoTr/udYMQoe27hP0t+jnNfd3O7m9lv56+QHOnTo0OE9iNMOy3To0KFDh0eAzrh36NChw3sQnXHv0KFDh/cgOuPeoUOHDu9BdMa9Q4cOHd6D6Ix7hw4dOrwH0Rn3Dh06dHgP4v8DHaliQss8qTAAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Predicted\\n Segmentation')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y_overlay.astype('uint8'))\n",
+    "plt.title('Overlaid\\n Segmentation')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/02_hsn_v1_lean/__pycache__/adp_cues.cpython-36.pyc b/02_hsn_v1_lean/__pycache__/adp_cues.cpython-36.pyc
new file mode 100644
index 0000000..ec1498f
Binary files /dev/null and b/02_hsn_v1_lean/__pycache__/adp_cues.cpython-36.pyc differ
diff --git a/02_hsn_v1_lean/__pycache__/dataset.cpython-36.pyc b/02_hsn_v1_lean/__pycache__/dataset.cpython-36.pyc
new file mode 100644
index 0000000..400c0f4
Binary files /dev/null and b/02_hsn_v1_lean/__pycache__/dataset.cpython-36.pyc differ
diff --git a/02_hsn_v1_lean/__pycache__/utilities.cpython-36.pyc b/02_hsn_v1_lean/__pycache__/utilities.cpython-36.pyc
new file mode 100644
index 0000000..f9127ff
Binary files /dev/null and b/02_hsn_v1_lean/__pycache__/utilities.cpython-36.pyc differ
diff --git a/02_hsn_v1_lean/adp_cues.py b/02_hsn_v1_lean/adp_cues.py
index e990db9..309d856 100644
--- a/02_hsn_v1_lean/adp_cues.py
+++ b/02_hsn_v1_lean/adp_cues.py
@@ -3,6 +3,8 @@
 from utilities import *
 
 class ADPCues:
+    """Class for handling ADP cues"""
+
     def __init__(self, model_name, batch_size, size, model_dir='models',
                  devkit_dir=os.path.join(os.path.dirname(os.getcwd()), 'database', 'ADPdevkit', 'ADPRelease1')):
         self.model_dir = model_dir
@@ -57,6 +59,13 @@ def __init__(self, model_name, batch_size, size, model_dir='models',
         self.unions['func'] = np.zeros((len(self.classes['valid_func'])))
 
     def get_img_names(self, set_name):
+        """Read image names from file
+
+        Parameters
+        ----------
+        set_name : str
+            Name of the dataset
+        """
         img_names = []
         if set_name is None:
             img_names_path = os.path.join(self.devkit_dir, 'ImageSets', 'Segmentation', 'input_list.txt')
@@ -69,6 +78,8 @@ def get_img_names(self, set_name):
         return img_names
 
     def build_model(self):
+        """Build CNN model from saved files"""
+
         # Load architecture from json
         model_json_path = os.path.join(self.model_dir, self.model_name, self.model_name + '.json')
         json_file = open(model_json_path, 'r')
@@ -94,6 +105,20 @@ def build_model(self):
             self.thresholds = 0.5 * np.ones(self.model.output_shape[-1])
 
     def read_batch(self, batch_names):
+        """Read batch of images from filenames
+
+        Parameters
+        ----------
+        batch_names : list of str (size: B), B = batch size
+            List of filenames of images in batch
+
+        Returns
+        -------
+        img_batch_norm : numpy 4D array (size: B x H x W x 3), B = batch size
+            Normalized batch of input images
+        img_batch : numpy 4D array (size: B x H x W x 3), B = batch size
+            Unnormalized batch of input images
+        """
         cur_batch_size = len(batch_names)
         img_batch = np.empty((cur_batch_size, self.size, self.size, 3), dtype='uint8')
         for i in range(cur_batch_size):
@@ -106,6 +131,20 @@ def read_batch(self, batch_names):
         return img_batch_norm, img_batch
 
     def get_grad_cam_weights(self, dummy_image, should_normalize=True):
+        """Obtain Grad-CAM weights of the model
+
+        Parameters
+        ----------
+        dummy_image : numpy 4D array (size: 1 x H x W x 3)
+            A dummy image to calculate gradients
+        should_normalize : bool, optional
+            Whether to normalize the gradients
+
+        Returns
+        -------
+        weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+            The Grad-CAM weights of the model
+        """
         def find_final_layer(model):
             for iter_layer, layer in reversed(list(enumerate(model.layers))):
                 if type(layer) == type(layer) == keras.layers.convolutional.Conv2D:
diff --git a/02_hsn_v1_lean/dataset.py b/02_hsn_v1_lean/dataset.py
index d8bf5dc..9b6182b 100644
--- a/02_hsn_v1_lean/dataset.py
+++ b/02_hsn_v1_lean/dataset.py
@@ -3,6 +3,8 @@
 import pandas as pd
 
 class Dataset:
+    """Class for implementing dataset handling"""
+
     def __init__(self, data_type='ADP', size=321, batch_size=16):
         self.data_type = data_type
         self.size = size
@@ -12,10 +14,10 @@ def __init__(self, data_type='ADP', size=321, batch_size=16):
         self.load_data()
 
     def load_attributes(self):
+        """Load dataset attributes, especially ImageDataGenerator"""
+
         if self.data_type == 'ADP':
             self.devkit_dir = os.path.join(self.database_dir, 'ADPdevkit', 'ADPRelease1')
-            # self.sets = ['train', 'valid', 'test']
-            # self.is_evals = [False, True, True]
             self.sets = ['valid', 'test']
             self.is_evals = [True, True]
             self.class_names = ['E.M.S', 'E.M.U', 'E.M.O', 'E.T.S', 'E.T.U', 'E.T.O', 'E.P', 'C.D.I', 'C.D.R', 'C.L', 'H.E',
@@ -52,8 +54,6 @@ def normalize(x):
                 preprocessing_function=normalize)  # normalize by subtracting training set image mean, dividing by training set image std
         elif self.data_type == 'VOC2012':
             self.devkit_dir = os.path.join(self.database_dir, 'VOCdevkit', 'VOC2012')
-            # self.sets = ['trainaug', 'val']
-            # self.is_evals = [False, True]
             self.sets = ['val']
             self.is_evals = [True]
             self.class_names = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
@@ -95,6 +95,8 @@ def normalize(x):
                 rescale=1. / 255)
 
     def load_data(self):
+        """Load DataFrameIterator for dataset"""
+
         self.set_gens = {}
         if self.data_type == 'ADP':
             img_folder = 'PNGImages'
diff --git a/02_hsn_v1_lean/demo.py b/02_hsn_v1_lean/demo.py
index 2d1b111..5a2c754 100644
--- a/02_hsn_v1_lean/demo.py
+++ b/02_hsn_v1_lean/demo.py
@@ -11,11 +11,30 @@
 MODEL_WSSS_ROOT = '../database/models_wsss'
 
 def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True, is_verbose=True):
+    """Predict segmentation on requested dataset using the provided seeding model with HistoSegNet, for VOC2012 and DeepGlobe
+
+    Parameters
+    ----------
+    dataset : str
+        The name of the dataset (i.e. 'ADP', 'VOC2012', 'DeepGlobe_train75', or 'DeepGlobe_train37.5')
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    batch_size : int
+        The batch size (>0)
+    set_name : str, optional
+        The name of the name of the evaluation set, if ADP (i.e. 'tuning' or 'segtest')
+    should_saveimg : bool, optional
+        Whether to save debug images
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
     assert(dataset in ['ADP', 'VOC2012', 'DeepGlobe_train75', 'DeepGlobe_train37.5'])
     assert(model_type in ['M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7', 'M7bg', 'VGG16', 'VGG16bg'])
     assert(os.path.exists(os.path.exists(os.path.join(MODEL_CNN_ROOT, dataset + '_' + model_type))))
     assert(batch_size > 0)
     assert(set_name in [None, 'tuning', 'segtest'])
+    assert(type(should_saveimg) is bool)
     assert(type(is_verbose) is bool)
     if model_type in ['VGG16', 'VGG16bg']:
         img_size = 321
@@ -64,7 +83,7 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
     # Load data and classes
     ds = Dataset(data_type=dataset, size=img_size, batch_size=batch_size)
     class_names, seg_class_names = load_classes(dataset)
-    colours = load_colours(dataset)
+    colours = get_colours(dataset)
     if 'DeepGlobe' in dataset:
         colours = colours[:-1]
     gen_curr = ds.set_gens[ds.sets[ds.is_evals.index(True)]]
@@ -77,7 +96,8 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
     n_batches = len(gen_curr.filenames) // batch_size + 1
     for iter_batch in range(n_batches):
         batch_start_time = time.time()
-        print('Batch #%d of %d' % (iter_batch + 1, n_batches))
+        if is_verbose:
+            print('\tBatch #%d of %d' % (iter_batch + 1, n_batches))
         start_idx = iter_batch * batch_size
         end_idx = min(start_idx + batch_size - 1, len(gen_curr.filenames) - 1)
         cur_batch_sz = end_idx - start_idx + 1
@@ -86,7 +106,8 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
         start_time = time.time()
         img_batch_norm, img_batch = read_batch(gen_curr.directory, gen_curr.filenames[start_idx:end_idx + 1],
                                                cur_batch_sz, (img_size, img_size), dataset)
-        print('\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
+        if is_verbose:
+            print('\t\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
                                                                           (time.time() - start_time) / cur_batch_sz))
 
         # Generate patch confidence scores
@@ -96,9 +117,9 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
         for fgbg_mode in fgbg_modes:
             predicted_scores[fgbg_mode] = mdl[fgbg_mode].predict(img_batch_norm)
             is_pass_threshold[fgbg_mode] = np.greater_equal(predicted_scores[fgbg_mode], thresholds[fgbg_mode])
-        print('\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' % (
-        time.time() - start_time,
-        (time.time() - start_time) / cur_batch_sz))
+        if is_verbose:
+            print('\t\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %
+                                                (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
 
         # Generate Grad-CAM
         start_time = time.time()
@@ -108,7 +129,8 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
                                     final_layer[fgbg_mode], predicted_scores[fgbg_mode], orig_sz=[img_size, img_size],
                                     should_upsample=True)
             H[fgbg_mode] = np.transpose(H[fgbg_mode], (0, 3, 1, 2))
-        print('\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
+        if is_verbose:
+            print('\t\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
                                                                     (time.time() - start_time) / cur_batch_sz))
 
         # Modify fg Grad-CAM with bg activation
@@ -122,7 +144,8 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
             Y_gradcam[:, 1:] = H['fg']
         elif 'DeepGlobe' in dataset:
             Y_gradcam = H['fg'][:, :-1, :, :]
-        print('\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
+        if is_verbose:
+            print('\t\tFg/Bg modifications time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
                                                                          (time.time() - start_time) / cur_batch_sz))
 
         # FC-CRF
@@ -132,18 +155,23 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
         elif 'DeepGlobe' in dataset:
             dcrf_config = np.array([3, 3, 80, 13, 10, 10])  # test
         Y_crf = dcrf_process(Y_gradcam, img_batch, dcrf_config)
-        print('\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
+        if is_verbose:
+            print('\t\tCRF time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
                                                                      (time.time() - start_time) / cur_batch_sz))
         elapsed_time = time.time() - batch_start_time
-        print('\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))
+        if is_verbose:
+            print('\t\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))
 
         if dataset == 'VOC2012':
             for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):
+                # Load GT segmentation
                 gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))
-                gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_RGB2BGR)[:, :, 0]
+                gt_idx = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)[:, :, 0]
+                # Load predicted segmentation
                 pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_idx.shape[1], gt_idx.shape[0]),
                                       interpolation=cv2.INTER_NEAREST)
                 pred_segmask = np.zeros((gt_idx.shape[0], gt_idx.shape[1], 3))
+                # Evaluate predicted segmentation
                 for k in range(len(colours)):
                     intersects[k] += np.sum((gt_idx == k) & (pred_idx == k))
                     unions[k] += np.sum((gt_idx == k) | (pred_idx == k))
@@ -151,23 +179,27 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
                     pred_segmask += np.expand_dims(pred_idx == k, axis=2) * \
                                     np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)
                     gt_count[k] += np.sum(gt_idx == k)
+                # Save outputted segmentation to file
                 if should_saveimg:
                     orig_filepath = os.path.join(img_dir, filename)
-                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)
+                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)
                     imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)
                     imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),
                                  (1 - OVERLAY_R) * orig_img / 256.0 +
                                  OVERLAY_R * pred_segmask / 256.0)
         elif 'DeepGlobe' in dataset:
             for iter_file, filename in enumerate(gen_curr.filenames[start_idx:end_idx + 1]):
+                # Load GT segmentation
                 gt_filepath = os.path.join(gt_dir, filename.replace('.jpg', '.png'))
-                gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_RGB2BGR)
+                gt_curr = cv2.cvtColor(cv2.imread(gt_filepath), cv2.COLOR_BGR2RGB)
                 gt_r = gt_curr[:, :, 0]
                 gt_g = gt_curr[:, :, 1]
                 gt_b = gt_curr[:, :, 2]
+                # Load predicted segmentation
                 pred_idx = cv2.resize(np.uint8(Y_crf[iter_file]), (gt_curr.shape[1], gt_curr.shape[0]),
                                       interpolation=cv2.INTER_NEAREST)
                 pred_segmask = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))
+                # Evaluate predicted segmentation
                 for k, gt_colour in enumerate(colours):
                     gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])
                     pred_mask = pred_idx == k
@@ -177,21 +209,24 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
                     pred_segmask += np.expand_dims(pred_mask, axis=2) * \
                                     np.expand_dims(np.expand_dims(colours[k], axis=0), axis=0)
                     gt_count[k] += np.sum(gt_mask)
+                # Save outputted segmentation to file
                 if should_saveimg:
                     orig_filepath = os.path.join(img_dir, filename)
-                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)
+                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)
                     orig_img = cv2.resize(orig_img, (orig_img.shape[0] // 4, orig_img.shape[1] // 4))
                     pred_segmask = cv2.resize(pred_segmask, (pred_segmask.shape[0] // 4, pred_segmask.shape[1] // 4),
                                               interpolation=cv2.INTER_NEAREST)
                     imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '.png'), pred_segmask / 256.0)
                     imgio.imsave(os.path.join(out_dir, filename.replace('.jpg', '') + '_overlay.png'),
                                  (1 - OVERLAY_R) * orig_img / 256.0 + OVERLAY_R * pred_segmask / 256.0)
+    # Evaluate mIoU and write to .xlsx file
     mIoU = np.mean(intersects / (unions + 1e-7))
     df = pd.DataFrame({'Class': seg_class_names + ['Mean'], 'IoU': list(intersects / (unions + 1e-7)) + [mIoU]},
                       columns=['Class', 'IoU'])
     xlsx_path = os.path.join(eval_dir, 'metrics_' + sess_id + '.xlsx')
     df.to_excel(xlsx_path)
 
+    # Generate confusion matrix for all classes and write to .png file
     count_mat = np.transpose(np.matlib.repmat(gt_count, len(colours), 1))
     title = "Confusion matrix\n"
     xlabel = 'Prediction'  # "Labels"
@@ -203,6 +238,7 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
     plt.savefig(os.path.join(eval_dir, 'confusion_' + sess_id + '.png'), dpi=96,
                 format='png', bbox_inches='tight')
 
+    # Generate confusion matrix for only foreground classes and write to .png file
     title = "Confusion matrix\n"
     xlabel = 'Prediction'  # "Labels"
     ylabel = 'Ground-Truth'  # "Labels"
@@ -222,6 +258,27 @@ def segment(dataset, model_type, batch_size, set_name=None, should_saveimg=True,
     plt.close()
 
 def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg, is_verbose):
+    """Predict segmentation on requested dataset using the provided seeding model with HistoSegNet, for ADP
+
+    Parameters
+    ----------
+    sess_id : str
+        The identifying string for the current session
+    model_type : str
+        The name of the model to use for generating cues (i.e. 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'X1.7', 'M7',
+        'M7bg', 'VGG16', or 'VGG16bg')
+    batch_size : int
+        The batch size (>0)
+    size : int
+        The length of the resized input image
+    set_name : str, optional
+        The name of the name of the evaluation set, if ADP (i.e. 'tuning' or 'segtest')
+    should_saveimg : bool, optional
+        Whether to save debug images
+    is_verbose : bool, optional
+        Whether to activate message verbosity
+    """
+
     ac = ADPCues(sess_id, batch_size, size, model_dir=MODEL_CNN_ROOT)
     OVERLAY_R = 0.75
 
@@ -249,7 +306,8 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
     n_batches = len(img_names) // batch_size + 1
     for iter_batch in range(n_batches):
         batch_start_time = time.time()
-        print('\tBatch #%d of %d' % (iter_batch + 1, n_batches))
+        if is_verbose:
+            print('\tBatch #%d of %d' % (iter_batch + 1, n_batches))
         start_idx = iter_batch * batch_size
         end_idx = min(start_idx + batch_size - 1, len(img_names) - 1)
         cur_batch_sz = end_idx - start_idx + 1
@@ -257,15 +315,17 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
         # Image reading
         start_time = time.time()
         img_batch_norm, img_batch = ac.read_batch(img_names[start_idx:end_idx + 1])
-        print('\t\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (
-        time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
+        if is_verbose:
+            print('\t\tImage read time: %0.5f seconds (%0.5f seconds / image)' % (time.time() - start_time,
+                                                                (time.time() - start_time) / cur_batch_sz))
 
         # Generate patch confidence scores
         start_time = time.time()
         predicted_scores = ac.model.predict(img_batch_norm)
         is_pass_threshold = np.greater_equal(predicted_scores, ac.thresholds)
-        print('\t\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' % (
-        time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
+        if is_verbose:
+            print('\t\tGenerating patch confidence scores time: %0.5f seconds (%0.5f seconds / image)' %
+                                    (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
 
         # Generate Grad-CAM
         start_time = time.time()
@@ -277,8 +337,9 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
         H_split['morph'], H_split['func'] = split_by_httclass(H, ac.classes['all'], ac.classes['morph'], ac.classes['func'])
         is_pass = {}
         is_pass['morph'], is_pass['func'] = split_by_httclass(is_pass_threshold, ac.classes['all'], ac.classes['morph'], ac.classes['func'])
-        print('\t\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' % (
-        time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
+        if is_verbose:
+            print('\t\tGenerating Grad-CAM time: %0.5f seconds (%0.5f seconds / image)' %
+                  (time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
 
         # Modify Grad-CAM for each HTT type separately
         Y_gradcam = {}
@@ -298,25 +359,30 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
                 Y_gradcam[htt_class] = modify_by_htt(Y_gradcam[htt_class], img_batch, ac.classes['valid_' + htt_class],
                                                      gradcam_adipose=gradcam_adipose)
             Y_csgc[htt_class] = get_cs_gradcam(Y_gradcam[htt_class], ac.classes['valid_' + htt_class], htt_class)
-            print('\t\t\tInter-HTT adjustments time [%s]: %0.5f seconds (%0.5f seconds / image)' % (htt_class,
-            time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
+            if is_verbose:
+                print('\t\t\tInter-HTT adjustments time [%s]: %0.5f seconds (%0.5f seconds / image)' %
+                      (htt_class, time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
 
             # FC-CRF
             start_time = time.time()
             dcrf_config = np.load(os.path.join(MODEL_WSSS_ROOT, htt_class + '_optimal_pcc.npy'))[0]
             Y_crf[htt_class] = dcrf_process(Y_csgc[htt_class], img_batch, dcrf_config)
-            print('\t\t\tCRF time [%s]: %0.5f seconds (%0.5f seconds / image)' % (htt_class,
-            time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
+            if is_verbose:
+                print('\t\t\tCRF time [%s]: %0.5f seconds (%0.5f seconds / image)' %
+                      (htt_class, time.time() - start_time, (time.time() - start_time) / cur_batch_sz))
 
             # Update evaluation performance
             _, gt_batch = read_batch(os.path.join(ac.gt_root, 'ADP-' + htt_class), img_names[start_idx:end_idx + 1], cur_batch_sz,
                                      [1088, 1088], 'ADP')
             for iter_img in range(cur_batch_sz):
-                pred_idx = cv2.resize(Y_crf[htt_class][iter_img], dsize=(1088, 1088), interpolation=cv2.INTER_NEAREST)
+                # Load GT segmentation
                 gt_r = gt_batch[iter_img][:, :, 0]
                 gt_g = gt_batch[iter_img][:, :, 1]
                 gt_b = gt_batch[iter_img][:, :, 2]
+                # Load predicted segmentation
+                pred_idx = cv2.resize(Y_crf[htt_class][iter_img], dsize=(1088, 1088), interpolation=cv2.INTER_NEAREST)
                 pred_segmask = np.zeros((1088, 1088, 3))
+                # Evaluate predicted segmentation
                 for k, gt_colour in enumerate(ac.colours[htt_class]):
                     gt_mask = (gt_r == gt_colour[0]) & (gt_g == gt_colour[1]) & (gt_b == gt_colour[2])
                     pred_mask = pred_idx == k
@@ -327,9 +393,10 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
                     pred_segmask += np.expand_dims(pred_mask, axis=2) * \
                                     np.expand_dims(np.expand_dims(ac.colours[htt_class][k], axis=0), axis=0)
                     gt_count[htt_class][k] += np.sum(gt_mask)
+                # Save outputted segmentation to file
                 if should_saveimg:
                     orig_filepath = os.path.join(ac.img_dir, img_names[start_idx + iter_img])
-                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_RGB2BGR)
+                    orig_img = cv2.cvtColor(cv2.imread(orig_filepath), cv2.COLOR_BGR2RGB)
                     pred_segmask_small = cv2.resize(pred_segmask, (orig_img.shape[0], orig_img.shape[1]),
                                                     interpolation=cv2.INTER_NEAREST)
                     imgio.imsave(
@@ -340,9 +407,11 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
                                  (1 - OVERLAY_R) * orig_img / 256.0 +
                                  OVERLAY_R * pred_segmask_small / 256.0)
         elapsed_time = time.time() - batch_start_time
-        print('\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))
+        if is_verbose:
+            print('\tElapsed time: %0.5f seconds (%0.5f seconds / image)' % (elapsed_time, elapsed_time / cur_batch_sz))
 
     for htt_class in ['morph', 'func']:
+        # Evaluate mIoU and write to .xlsx file
         mIoU = np.mean(ac.intersects[htt_class] / (ac.unions[htt_class] + 1e-7))
         df = pd.DataFrame({'Class': ac.classes['valid_' + htt_class] + ['Mean'],
                            'IoU': list(ac.intersects[htt_class] / (ac.unions[htt_class] + 1e-7)) + [mIoU]},
@@ -353,6 +422,7 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
         xlsx_path = os.path.join(eval_dir, 'metrics_ADP-' + htt_class + '_' + model_type + '.xlsx')
         df.to_excel(xlsx_path)
 
+        # Generate confusion matrix for all classes and write to .png file
         count_mat = np.transpose(np.matlib.repmat(gt_count[htt_class], len(ac.classes['valid_' + htt_class]), 1))
         title = "Confusion matrix\n"
         xlabel = 'Prediction'  # "Labels"
@@ -365,6 +435,7 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
                     format='png', bbox_inches='tight')
         plt.close()
 
+        # Generate confusion matrix for only foreground classes and write to .png file
         title = "Confusion matrix\n"
         xlabel = 'Prediction'  # "Labels"
         ylabel = 'Ground-Truth'  # "Labels"
@@ -384,17 +455,17 @@ def segment_adp(sess_id, model_type, batch_size, size, set_name, should_saveimg,
 
 if __name__ == "__main__":
     # ADP
-    # segment(dataset='ADP', model_type='VGG16', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
-    # segment(dataset='ADP', model_type='VGG16', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
-    # segment(dataset='ADP', model_type='X1.7', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
-    # segment(dataset='ADP', model_type='X1.7', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
+    segment(dataset='ADP', model_type='VGG16', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
+    segment(dataset='ADP', model_type='VGG16', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
+    segment(dataset='ADP', model_type='X1.7', batch_size=16, set_name='tuning', should_saveimg=True, is_verbose=True)
+    segment(dataset='ADP', model_type='X1.7', batch_size=16, set_name='segtest', should_saveimg=True, is_verbose=True)
 
     # VOC2012
-    # segment(dataset='VOC2012', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
-    # segment(dataset='VOC2012', model_type='M7', batch_size=16, should_saveimg=True, is_verbose=True)
+    segment(dataset='VOC2012', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
+    segment(dataset='VOC2012', model_type='M7', batch_size=16, should_saveimg=True, is_verbose=True)
 
     # DeepGlobe
-    # segment(dataset='DeepGlobe_train75', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
-    # segment(dataset='DeepGlobe_train75', model_type='M7', batch_size=16, should_saveimg=True, is_verbose=True)
-    # segment(dataset='DeepGlobe_train37.5', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
+    segment(dataset='DeepGlobe_train75', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
+    segment(dataset='DeepGlobe_train75', model_type='M7', batch_size=16, should_saveimg=True, is_verbose=True)
+    segment(dataset='DeepGlobe_train37.5', model_type='VGG16', batch_size=16, should_saveimg=True, is_verbose=True)
     segment(dataset='DeepGlobe_train37.5', model_type='M7', batch_size=16, should_saveimg=True, is_verbose=True)
\ No newline at end of file
diff --git a/02_hsn_v1_lean/utilities.py b/02_hsn_v1_lean/utilities.py
index b471e95..ac15bd4 100644
--- a/02_hsn_v1_lean/utilities.py
+++ b/02_hsn_v1_lean/utilities.py
@@ -12,6 +12,20 @@
 import matplotlib.pyplot as plt
 
 def build_model(model_dir, model_name):
+    """Build model from saved files
+
+    Parameters
+    ----------
+    model_dir : str
+        Directory holding the model files
+    model_name : str
+        The name of the model files
+
+    Returns
+    -------
+    model : keras.engine.sequential.Sequential object
+        The built model from file
+    """
     # Load architecture from json
     model_json_path = os.path.join(model_dir, model_name + '.json')
     json_file = open(model_json_path, 'r')
@@ -29,11 +43,39 @@ def build_model(model_dir, model_name):
     return model
 
 def load_thresholds(model_dir, model_name):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     thresh_path = os.path.join(model_dir, model_name + '.mat')
     tmp = io.loadmat(thresh_path)
     return tmp.get('optimalScoreThresh')
 
 def load_classes(dataset):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     if dataset == 'VOC2012':
         class_names = ['aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat', 'chair', 'cow',
                    'diningtable', 'dog', 'horse', 'motorbike', 'person', 'pottedplant', 'sheep', 'sofa', 'train',
@@ -46,26 +88,21 @@ def load_classes(dataset):
         seg_class_names = class_names
     return class_names, seg_class_names
 
-def load_colours(dataset):
-    if dataset == 'VOC2012':
-        return np.array([(0, 0, 0), (128, 0, 0), (0, 128, 0), (128, 128, 0),
-                          (0, 0, 128), (128, 0, 128), (0, 128, 128), (128, 128, 128),
-                          (64, 0, 0), (192, 0, 0), (64, 128, 0), (192, 128, 0),
-                          (64, 0, 128), (192, 0, 128), (64, 128, 128), (192, 128, 128),
-                          (0, 64, 0), (128, 64, 0), (0, 192, 0), (128, 192, 0),
-                          (0, 64, 128)])  # using palette for pascal voc
-    elif 'DeepGlobe' in dataset:
-        return np.array([(0, 255, 255), (255, 255, 0), (255, 0, 255), (0, 255, 0), (0, 0, 255),
-                        (255, 255, 255), (0, 0, 0)])
-    elif dataset == 'CityScapes':
-        return np.array([(0, 0, 0), (111, 74, 0), (81, 0, 81), (128, 64, 128), (244, 35, 232), (250, 170, 160),
-                         (230, 150, 140), (70, 70, 70), (102, 102, 156), (190, 153, 153), (180, 165, 180),
-                         (150, 100, 100), (150, 120, 90), (153, 153, 153), (153, 153, 153), (250, 170, 30),
-                         (220, 220, 0), (107, 142, 35), (152, 251, 152), (70, 130, 180), (220, 20, 60), (255, 0, 0),
-                         (0, 0, 142), (0, 0, 70), (0, 60, 100), (0, 0, 90), (0, 0, 110), (0, 80, 100), (0, 0, 230),
-                         (119, 11, 32), (0, 0, 142)])
-
 def get_colours(segset):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     if segset == 'ADP-morph':
         return np.array([(255, 255, 255), (0, 0, 128), (0, 128, 0), (255, 165, 0), (255, 192, 203),
                          (255, 0, 0), (173, 20, 87), (176, 141, 105), (3, 155, 229),
@@ -88,6 +125,20 @@ def get_colours(segset):
                          (255, 255, 255), (0, 0, 0)])
 
 def normalize(dataset, x):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     if dataset == 'VOC2012':
         x[:, :, 0] -= 104
         x[:, :, 1] -= 117
@@ -99,6 +150,28 @@ def normalize(dataset, x):
         return x / 255
 
 def read_batch(img_dir, batch_names, batch_sz, sz, dataset):
+    """Read a batch of images
+
+    Parameters
+    ----------
+    img_dir : str
+        Directory holding the input images
+    batch_names : list of str
+        Filenames of the input images
+    batch_sz : int
+        The batch size
+    img_mean : list of float (size: 3), optional
+        Three-channel image set mean
+    img_std : list of float (size: 3), optional
+        Three-channel image set standard deviation
+
+    Returns
+    -------
+    img_batch_norm : numpy 4D array (size: B x H x W x 3), B = batch size
+        Normalized batch of input images
+    img_batch : numpy 4D array (size: B x H x W x 3), B = batch size
+        Unnormalized batch of input images
+    """
     img_batch = np.empty((batch_sz, sz[0], sz[1], 3), dtype='uint8')
     for i in range(batch_sz):
         if 'PNGImages' in img_dir:
@@ -111,6 +184,22 @@ def read_batch(img_dir, batch_names, batch_sz, sz, dataset):
     return img_batch_norm, img_batch
 
 def get_grad_cam_weights(input_model, dummy_image, should_normalize=True):
+    """Obtain Grad-CAM weights of the model
+
+    Parameters
+    ----------
+    input_model : keras.engine.sequential.Sequential object
+        The input model
+    dummy_image : numpy 4D array (size: 1 x H x W x 3)
+        A dummy image to calculate gradients
+    should_normalize : bool, optional
+        Whether to normalize the gradients
+
+    Returns
+    -------
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    """
     def find_final_layer(model):
         for iter_layer, layer in reversed(list(enumerate(model.layers))):
             if type(layer) == type(layer) == keras.layers.convolutional.Conv2D:
@@ -140,7 +229,33 @@ def normalize(x):
 
 
 def grad_cam(input_model, weights, images, is_pass_threshold, final_layer, conf_scores, orig_sz=[224, 224],
-             should_upsample=False, batch_size=16):
+             should_upsample=False):
+    """Generate Grad-CAM
+
+    Parameters
+    ----------
+    input_model : keras.engine.sequential.Sequential object
+        The input model
+    weights : numpy 2D array (size: F x C), where F = number of features, C = number of classes
+        The Grad-CAM weights of the model
+    images : numpy 4D array (size: B x H x W x 3), where B = batch size
+        The batch of input images
+    is_pass_threshold : numpy 2D bool array (size: B x C), where B = batch size, C = number of classes
+        An array saving which classes pass the pre-defined thresholds for each image in the batch
+    final_layer : str
+        The name of the final layer
+    conf_scores : numpy 2D array (size: B x C), where B = batch size, C = number of classes
+        The confidence scores for each class of each image in the batch
+    orig_sz : list of int, optional
+        2D size of original images
+    should_upsample : bool, optional
+        Whether to upsample the generated Grad-CAM activation maps to original input size
+
+    Returns
+    -------
+    cams : numpy 4D array (size: B x H x W x C), B = batch size, C = number of classes
+        The thresholded Grad-CAMs
+    """
     conv_output = input_model.get_layer(final_layer).output  # activation_7
     conv_func = K.function([input_model.layers[0].input], [conv_output])
     conv_val = conv_func([images])
@@ -164,11 +279,50 @@ def grad_cam(input_model, weights, images, is_pass_threshold, final_layer, conf_
 
 
 def split_by_httclass(H, all_classes, morph_classes, func_classes):
+    """Split classes in incoming variable by HTT class
+
+    Parameters
+    ----------
+    H : numpy <=2D array (size: B x C x ?), where B = batch size, C = number of classes
+        Variable to be split
+    all_classes : list of str
+        List of all classes
+    morph_classes : list of str (size: C_morph), where C_morph = number of morphological classes
+        List of morphological classes, a subset of all_classes
+    func_classes : list of str (size: C_func), where C_func = number of functional classes
+        List of functional classes, a subset of all_classes
+
+    Returns
+    -------
+    (H_morph) : numpy <=2D array (size: B x C_morph x ?), where B = batch size, C_morph = number of morphological classes
+        Split morphological classes in variable
+    (H_func) : numpy <=2D array (size: B x C_func x ?), where B = batch size, C_morph = number of functional classes
+        Split functional classes in variable
+    """
     morph_all_inds = [i for i, x in enumerate(all_classes) if x in morph_classes]
     func_all_inds = [i for i, x in enumerate(all_classes) if x in func_classes]
     return H[:, morph_all_inds], H[:, func_all_inds]
 
 def modify_by_htt(gradcam, images, classes, gradcam_adipose=None):
+    """Generates non-foreground class activations and appends to the foreground class activations
+
+    Parameters
+    ----------
+    gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+        The serialized Grad-CAM for the current batch
+    images : numpy 3D array (size: self.batch_size x H x W x 3)
+        The input images for the current batch
+    classes : list (size: C), where C = number of classes
+        The list of classes in gradcam
+    gradcam_adipose : numpy 4D array (size: self.num_imgs x C x H x W), where C = number of classes,
+                      or None, optional
+        Adipose class Grad-CAM (if segmenting functional types) or None (if not segmenting functional types)
+
+    Returns
+    -------
+    gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+        The modified Grad-CAM for the current batch, with non-foreground class activations appended
+    """
     if gradcam_adipose is None:
         htt_class = 'morph'
     else:
@@ -206,12 +360,27 @@ def modify_by_htt(gradcam, images, classes, gradcam_adipose=None):
         other_moh = np.max(gradcam, axis=1)
         other_gradcam = np.expand_dims(other_tissue_mult * (1 - other_moh), axis=1)
         other_gradcam = np.max(np.concatenate((other_gradcam, gradcam_adipose), axis=1), axis=1)
-        # other_gradcam = np.clip(other_gradcam, 0, 1)
         gradcam[:, other_ind] = other_gradcam
     return gradcam
 
 
 def get_cs_gradcam(gradcam, classes, htt_class):
+    """Generates class-specific Grad-CAMs from incoming Grad-CAMs
+
+    Parameters
+    ----------
+    gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+        The Grad-CAM for the current batch
+    classes : list (size: C), where C = number of classes
+        The list of classes in gradcam
+    htt_class : str
+        The type of segmentation set to solve
+
+    Returns
+    -------
+    cs_gradcam : numpy 4D array (size: self.batch_size x C x H x W), where C = number of classes
+        The class-specific Grad-CAM for the current batch
+    """
     if htt_class in ['func', 'glas']:
         other_ind = classes.index('Other')
     # Find max difference value, ind map
@@ -227,8 +396,24 @@ def get_cs_gradcam(gradcam, classes, htt_class):
             cs_gradcam[:, iter_class] = gradcam[:, iter_class]
     return cs_gradcam
 
-
 def dcrf_process(probs, images, config):
+    """
+    Run dense CRF, given probability map and input image
+
+    Parameters
+    ----------
+    probs : numpy 4D array
+        The class probability maps, in batch
+    images : numpy 4D array
+        The original input images, in batch
+    config : 6-tuple of float
+        Requested CRF configurations
+
+    Returns
+    -------
+    maxconf_crf : numpy 3D array
+        The discrete class segmentation map from dense CRF, in batch
+    """
     gauss_sxy, gauss_compat, bilat_sxy, bilat_srgb, bilat_compat, n_infer = config
 
     # Set up variable sizes
@@ -259,8 +444,23 @@ def dcrf_process(probs, images, config):
     maxconf_crf = np.argmax(crf, axis=1)
     return maxconf_crf
 
-
 def maxconf_class_as_colour(maxconf_crf, colours, size):
+    """Convert 3D discrete segmentation masks (indices) into 4D colour images, based on segmentation colour code
+
+    Parameters
+    ----------
+    maxconf_crf : numpy 3D array (size: B x H x W), where B = batch size
+        The maximum-confidence index array
+    colours : numpy 2D array (size: N x 3), where N = number of colours
+        Valid colours used in the segmentation mask images
+    size : list (size: 2)
+        Size of the image
+
+    Returns
+    -------
+    Y : numpy 4D array (size: B x H x W x 3), where B = batch size
+        The 4D outputted discrete segmentation mask image
+    """
     num_input_images = maxconf_crf.shape[0]
     Y = np.zeros((num_input_images, size[0], size[1], 3), dtype='uint8')
     for iter_input_image in range(num_input_images):
@@ -269,6 +469,20 @@ def maxconf_class_as_colour(maxconf_crf, colours, size):
     return Y
 
 def resize_stack(stack, size):
+    """Resize stack to specified 2D size
+
+    Parameters
+    ----------
+    stack : numpy 4D array (size: B x C x H x W), where B = batch size, C = number of classes
+        The stack to be resized
+    size : list of int
+        The 2D size to be resized to
+
+    Returns
+    -------
+    stack : numpy 4D array (size: B x C x H x W), where B = batch size, C = number of classes
+        The resized stack
+    """
     old_stack = stack[:]
     stack = np.zeros((stack.shape[0], stack.shape[1], size[0], size[1]))
     for i in range(stack.shape[0]):
diff --git a/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-func-checkpoint.ipynb b/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-func-checkpoint.ipynb
new file mode 100644
index 0000000..bcc5b85
--- /dev/null
+++ b/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-func-checkpoint.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-adp-func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 14134, 'segtest': 50}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'ADP-func'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, \n",
+    "                             '--seed', seed_type, '--setname', setname, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\ADP-func_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\ADP-func_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Functional\\n ground truth')"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(gt_curr.astype('uint8'))\n",
+    "plt.title('Functional\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-morph-checkpoint.ipynb b/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-morph-checkpoint.ipynb
new file mode 100644
index 0000000..bad6b4c
--- /dev/null
+++ b/03_sec-dsrg/.ipynb_checkpoints/03_sec-adp-morph-checkpoint.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-adp-morph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 14134, 'segtest': 50}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'ADP-morph'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, \n",
+    "                             '--seed', seed_type, '--setname', setname, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\ADP-morph_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\ADP-morph_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Morphological\\n ground truth')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(gt_curr.astype('uint8'))\n",
+    "plt.title('Morphological\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/.ipynb_checkpoints/03_sec-deepglobe-checkpoint.ipynb b/03_sec-dsrg/.ipynb_checkpoints/03_sec-deepglobe-checkpoint.ipynb
new file mode 100644
index 0000000..c11419d
--- /dev/null
+++ b/03_sec-dsrg/.ipynb_checkpoints/03_sec-deepglobe-checkpoint.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-voc2012"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 10582, 'val': 1449}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'VOC2012'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, '--seed', seed_type, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    gt_mask = (gt_curr[:, :, 0] == gt_colour[0]) & (gt_curr[:, :, 1] == gt_colour[1]) & (gt_curr[:, :, 2] == gt_colour[2])\n",
+    "    G += np.expand_dims(gt_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth segmentation')"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAACeCAYAAADe3trJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOydeZgdVZn/P6fqrr1v6ewbWQlhJ+wgsojs4GhYlU0jzqiM4yAIbqijIsoojuPoOLgMjrj9XIgIKqCyBSQQAoFsZOtOOp1O73232s7vj6q6OX26bneCBBuo7/Pc595bdepsder7vud933NKSCmJESNGjBhvDhh/7wrEiBEjRozXDjHpx4gRI8abCDHpx4gRI8abCDHpx4gRI8abCDHpx4gRI8abCDHpx4gRI8abCDHp/40QQtwshPjuq512L/KSQoi5Fc79Tghx5atRTow3DoQQW4QQp7/GZX5GCHH3a1nm6x1CiDVCiFP2V/4x6SsQQlwlhHheCJEXQuwUQnxLCNEw2jVSyi9IKd+7N/nvS9q/BVLKs6SUP9jf5cQYDiHEJUKIJ4UQOSHEruD3PwohxN+7bmNBCPF9IcTn/8Y8ThFCtL9adXo9Yl8Fa1S/SykPklL+6VWvXICY9AMIIT4K3AbcANQDxwIzgT8IIVIVrkm8djWMMZ4RjJ+vA7cDk4CJwHXACUCl8WO+ZhX8GxGP9TcQpJRv+g9QBwwBS7XjNcAu4Jrg/2eAnwN3AwPAe4NjdyvXvAfYCnQDnwS2AKcr198d/J4FSOBKYBuwG7hFyedo4AmgD+gA/gNIKeclMLdCe/4EvDf4fRXwGPDvQV6bgOOD421B+65Urj0HeDZoXxvwGS3v0dpnADcBLwfnfwo0/b3v72swfuqBHPAPY6T7PvAt4L4g/enBtT8EuoJ+/QRg6ONFGzMJ5T5/Lri/g8DvgRYl/buVe3WLeq+0ei0DbMDCfw7uDY5vAW4EVgMlIKGPu6BNnweqgQLgBXkMAVOCNvw0aOMgsAY4qkL/iGCc7gL6g3IXB+fSwFfwn5VO4L+ArHLtx/Cfkx34z2W5nkEd/xP4XVCvx/AF89eAXmAtcLiS1xTgF8E92Qx8WDlXsT3A/wbtLwTlfCw4/jNgZ9CmvwAH7UW/n660+2tBu3YEv9PBuVOAduCjQZ91AFePNV5jTd/H8UAG+H/qQSnlEP5AOUM5fAE+8TcAP1LTCyEW4Q+uy4HJ+A/01DHKPhFYAJwGfEoIcWBw3AU+ArQAxwXn/3Ef2xXiGPwHqBn4P+AeYAkwF7gC+A8hRE2QNodP7A34AuADQogL97J9HwYuBN6C/+D0At98hXV+PeE4/Ifz13uR9jLg34Ba4FHgG/j9eAB+v70HuHofyr4sSN+KP6P4Vyjfq2/hE/8U/Hs/LSoDKeV38Mfyl6WUNVLK85TTl+KPgwYppVOpElLKHHAWsCPIo0ZKuSM4fT7+mGsAfoOvwEThbcDJwPwg7cX4Agv8Wfh84DD8cTsV+FTQ1rcD/4IvROfi96OOpfgCtQVfgD0BPBP8/zlwR5CXAdwLPBeUcRrwz0KIM5W8ItsjpXw3vlA6L2j/l4P0vwPm4d+jZwh4Y4x+D3ELvtXhMOBQfGXwE8r5Sex5Dq8FvimEaIzIp4yY9H20ALsrDOqO4HyIJ6SUv5JSelLKgpb2nfjS+lEppYU/KMfa3OhWKWVBSvkc/kA7FEBKuVJKuUJK6UgptwDfJnow7w02Sym/J6V0gZ8A04HPSilLUsrf42sac4Ny/ySlfD5o32rgx0q5Y7Xv/fizlXYpZQlfK3rnm8A0MGL8CCEeF0L0CSEKQoiTlbS/llI+JqX08LW8i4GPSykHg/v8VXyi3lt8T0q5PhiLP8UnB/Dv1XIp5V+Ce/FJfC10X3GnlLItYqzvCx6VUt4XjL//JRjjEbDxheFCQEgpX5JSdgQ+kfcBH5FS9kgpB4EvAJcE1y3F74c1Uso8cGtE3r8Mnqki8EugKKX8ofJMHB6kWwJMkFJ+VkppSSk3Af+tlLUv7QFASnlXcH/DZ+JQIUT9aNcouBz/Wd0lpewK2qaODzs4b0sp78OfMSwYLcM3+sO4t9gNtAghEhHEPzk4H6JtlHymqOellHkhRPco6cGf9oXI45uUEELMx9c+jgKq8O/VyjHyqoRO5XchqJt+LCz3GOBLwGJ8zTGNPz2Fsds3E/ilEEIlFxffvr39Fdb99YButPEjpTweIHBsqsqVOn5a8Pt4q3JsK2PPDlVEjh9G3qvcXozFKIw23vcWeh0zUc+alPIhIcR/4M8OZwghfok/c8ngPwMrFZ+4AEKfyBTg6THqrI/3yPGPP4anCCH6lPMm8Mi+tgfKfpt/A94FTGCP4G3BN/eMhSmMHB9TlP/dWrnqGIhErOn7eAJ/yvcO9aAQohp/yvqgcng0zb0DZQothMjiT6tfCb6Fb2ucJ6WsA27GH+j7G/+HP2WdLqWsx7edhuWO1b424CwpZYPyyUgp38iED3vGzwV7kVYdP7vxNbWZyrEZ7BGQOXyyCzFpH+rUgT+jA0AIUcXoY7HSuNaP50ep09+8Za+U8k4p5ZHAQfjmnBvw+6mAbwsPx1W9lDIkt2HjEqXdrwBt+DNjdQzXSinP3tsmaP8vwx8Xof9mVnBcVEivYwcjx8eOCmn3CjHpA1LKfvxp0zeEEG8XQiSFELPwNdx2/Cnc3uDnwHlCiOODiJ9beeVEXYvvTB0SQiwEPvAK83kl5fZIKYtCiKPxB22Isdr3X8C/CSFmAgghJggh9oYIX9eQUvbh98V/CiHeKYSoEUIYQojD8B2cla5z8U0y/yaEqA367V/wAwUAVgEnCyFmBOaAj+9DtX4OnCuEODG4V59l9Oe9E9+vMBZWAZcJIczAlq6aHDuB5n0wXQyDEGKJEOIYIUQSX+AVATcwhf038O9CiNYg7VTFzv5T4GohxIGBcPvUKyk/wFPAgBDiRiFENmjnYiHEkr28Xu/HWnyFoBtfWH5hjPQ6fgx8IniWWvDb9jete4hJP0DgdLkZP0JgAHgSX+qfFtji9iaPNcCH8J08Hfje/V34N31f8a/4hDuIP+B/8gryeCX4R+CzQohB/AH20/DEXrTv6/izhN8H16/AdyK/4RGMn3/BjyLZhf8wfxs/+uXxUS79ED7BbcJ37P4fcFeQ5x/w7/tqfNPe8n2ozxrgn4L8OvCd6qPF0P8PsCjwQ/xqlHTXA+fhR4JdDpTTSinX4pPUpiCfKdFZVEQd/ljvZU/U0VeCczcCG4EVQogB4I8Etmsp5e+AO4GHgzRPBNfs83MXCOLz8H0jm/FnGd/F19L3Bl/EJ+k+IcS/4kf5bMWfvb2I/0yoGKvfP49vuloNPI/vCP7b1lNIGb9EZX8hiIjpwzfRbP571+fVxhu9fTFenwgi4F7AD22sGHH0ZkWs6b/KEEKcJ4SoCvwBX8GXzlv+vrV69fBGb1+M1yeEEBcJIVJBuOJt+FFmMeFHYL+QfmAXXyeE2CiEuGl/lDGOcQF7FlLMAy6Rb6zp1Bu9faPiTT62xzPej7+Y6mX8iLHXygf2usOrbt4JQpTW4y9oagf+ClwqpXzxVS0oRozXGPHYjvFGwP7Q9I8GNkopNwULeO5h70LZYsQY74jHdozXPfbH4qypDF8c0c4YERwNDQ1y6tTo9SjhYgwpZfm3fq4S9iX9WDOe8LwQolyXStdUKieqDZWwt+n2NW2YXq37aG15pVDbqv9+NcvYmzTt7e309va+Gmsc9nlsCyHeNKavGH8fSCn3aWzvD9KPqsCIgS+EWIa/4RCTJ0/mnnvuQQgxjFQBTNNfdCelHPY7TBt+DMMYdm14fXhOKXfY+TC/8Fv9hNd5njfsW71WFwJhmrA+IQzDwHXdYXnq9Qjbp9YlPBbVtvC82ia1LiqZq/2h9m/4P4qkdVJV26+n18tRj6ltEkLgeV5kP4S/w3w8z4skdjVvte7q9Wqac889d0QerxD7PLZjxBhv2B/mnXaGr4ibRsQKMinld6SUR0kpj2psbFSPD3vwVYIJSUAlePW68KFXyUIntfC467p4nhd5DTBMUITQCVcXHFFEqJOwmpf+HaZXiTAqH7V8XVCFUIVB2BbDMIb1X1R91LqoddDbH+ZZieyjhI1aj0rlqv0ZdR+i6qIiFEzqfX4VZxf7PLZfrYJjxHi1sD9I/6/APCHEbOGvBLwEf8HOqNBJM4SqHYfnVPKPykcnx/C3qrFHkax6TkclktbLiBJaUYgiybBdlfJWy9VnEjqitORQw9aP623T27c35iNdAOuCeTRTWNQsRq+XKmxGm51ECcZ9NX+Nglc0tmPEGE941c07UkpHCPFB4AH8jYrukv7qwFER9cBX0qpVgtbNBOq1o5GWmqdhGJGmmxAhUY5G4DrpqWYM3eygp9NJN0pL1suLMg/pdVVJvlJf6n2i/64kKPT0en9HzU4qpY3qw9HK0LV5Ne1o7ftb8UrHdowY4wn7ZZdN6W/xed++XBNO/ysR1Gi/I8of8eDrBKRer2rYFdoz4hpdg40y4YQwTbMieerXh1BnMWpZal46VGEQZX7ShcTeEqQ+2wCGmcXGymNfSThKWOgmo70VKKGAeLXwSsZ2jBjjCeNia2VVq9Sn+pXIW782SrusRPKVNM1KUNOEhOu6bqT5QjfvqKQTRZ6VTElRhKyT7Fh9E1X/qHL03zpGOz6asIuauYxm8qlUF13IqjOZqDrqs4MYMWLswbjahiHKplxpyh5FCrowiHr4Vf+Amr/+UU0I6ieEmo9ul9ZRiahD4hqLFHX7fZRJSLehj0V2entUwRtFylEzC/VclGAYrT7hzE4tv5JAiJq9RNU9TBPl6I8RI4aPcUH6lTTQKBOMCl0DrETU6vWVZgJ6XaLO6bZklaTHEkw6uYfnVULX8xlNe1bLV+taKTImqs/C9JU0YzX/Snb0SsfCNkc5nHUBorZBNfFFmdFc1x1Rji4IovoiRowYPsaVeaeSOUBFpdmATtKVTED6tVHpVOhapkosupO2Uj56PVUzkZ4+zEslTPV3JY1fzadShI5qFlHLGW2Wotcrqp2VzHCh/0EXpHp7K5l7wmNjzWD25roYMWL4GBeqUJQpR9d+dfODrr1XmgXoZoBKBKKSXpivGiGja9RR2q+eb7gOQDc/hAIjTKPXWxckeh302YE+MxhNG1e/K5lkohCldet9EoUooVTpnoTfUc7XSoKpUtl7I8hixHgzYlxo+iqiyFvViEPtWtVmo8wjlUw3YzlCQw01yqYcRcY6aen5qXlVIij9WlU4qKuQ1fM6KgmwSogyS0X131h56fdnrPz1uqr9GiUc9XrpAqGS0Ik1/BgxojEuNH2obG7R/0dtiVBJi40yP1SaQajpopyZKulEaclRhK+afyoRfxQp6m3T66B/1GvVmUAlQaH3dVQfRJUbVf8ok416TnV468IhSqjo9dYFgd53o/Wn3u4YMWKMI02/kkbouu6IPWnCczrUY+pswPO8ch6hI7DSyk61jEqaq/o/TKcu8NJNLvpsQI+zD8M/1WuiZiNqP+jndRu9bmdX2zka6Ua1P0rD1vu9kiYeVXbU/0plVxIy6u+xZhgxYsTYg3FD+hBNTJXMNHr60c7pxK8SZKUyVPJSibqSsInSinUnaSgYwvpEaewqaamCQS07iqSjro+aCai/9TLU86ogU6+Ncszq+VfqHz0vfbYVZQ7SBble/6i66/0QI0aMPRgXpB9F9uFxHZUIPvwfNRNQzTa6A1XXiEPohKfanqNIKSxb9z+o1+r11M0saj3UaB3V5FIpJLNS/+kkGqUVV8JoeVWC3rZKM4yoMqLKGovgdQGr5xuTfowYwzEuSD9ElLasYjRtOIrMokgjao8dVSvWiSqEvn+OLizCfNUN4vR6qdCdxWq+4TmV8MOZik7iUf2nI4oAKwlIPb3e1qg+jRIsan+HZrrw+tGEe5T5qVK9wvwrtScm/hgxRmJckb6K0R7UqOX3+sZrlQhAJ+5KWmnUNVEaeZTpSb0uSrhE5R3+jtLwo/LRy1RnInr7dAGopt0bQlTThj6W0Uwr+m9d0EYt9BotMmq0hWF7MzuMESPGHowb0tf3kB/LBFJJO1VXdEYRrF5OiL0xW4yG0WYHlUgpavfOqLaOpsGrIay6+alSWytp0LoJLKpN+orZ0WYJanui1iOo51Vzmi4cotqt90uU6S0WADFijMS4CdkMFzLpIZHqt+78rBQpohNdeK2an+6o1a/TTRpq/uG3Xk/9o5ejHlfXGejCR10XoNY77BvVVKKWE9VeNQ89nd7Xarm6UIjSttWZhH7vVEGizzT0857nDYtgihI2Uf0dda7SDC9GjBg+xoWmH2X2CKFrw2ooZrjbZVQoYxQ5hPZ2XTMO365UyVZcKWIlxGi7PVaynVeazeiasap1R53X2xsSb9QaAb0OUX2u95tuCtJnEaORqppGrZNelm5ei6qHikrCUj8fI0aMkRgXpA/RNm71eAjdBBBly4+ygavO1Uok7TjOCHJTSTYqz0rkFCXI1DbqWnrUO2N1c5R6Pqpden0r9aNqxokSclHXRX1HtVlvZyUijyLs0dKp3/rW1qMRfiwAYsQYjnFD+hBtl9cf2ihNVV/spOYV/q7kTNS16tE0dbV+sHeROlHXhvWp5Ceo5M+oZNrQ66oKPp2A1bRjbYamYm/enqX/H0vwhMd0ko/q86i+GS3v8N6M5YuJEePNhnFF+qpGq5s1dM0bKIcxRjkgw/zC70qauJp/JR+BDtWmXmnWENZvtHpEacRR5hTd/6D+rkSOan9UMitFkXwlUg01a7UsXYioZYylgavQ048WrRNVbpSpKTQleZ4HsbIfI0YZ44L0hRAjCCp8iCsRuWpeUX9XIhpdk9VJTSXWcEtgYJgPQL9WN7Wo5VaqR5SwUesQ9sVo10SRbRTRjla/qBmATqBR7VURZX6J6p9KMwvVVBdVV10Y6vWs1JYRAi9W9mPEKGNckH4IlRDCb13z1G3zlVbA6vmOZYZQiVaNJFGjYNRrKxGhmkafRah1VOugHwud01EmIF07r0TMutCMavdoM5VKAkP9X0n4RGn9+jWVwlnVfNQ66P2sCoook9mw2cIos4wYMd5sGDekr2rXUaQdBf2VhVFaYyVbNETbnytpzurvSqag8FwlrVrPJ/yva8C6JjuWmURPowvKqLqOZs6KsrdHla9r3vrsazShoQvUqLpGCeuo/KLCYitdGyPGmx3jhvSjCF+f0qu2+yhzAkSTZJSZIMp2rRKPvj1xFNlFlR11Lspmr5qjdEe0Xg+9TL1vdIxW16j+EELstZ8iysSkYrSZT5RpShcAanr9/kQdr2TPr1S/GDHe7BhzcZYQ4i4hxC4hxAvKsSYhxB+EEBuC78bguBBC3CmE2CiEWC2EOGJvK6I+vKHWqJsYKhFOFLGFCPMZrTzV5BCW4bpuOX5ftx+rn9BZqMf6q3mq73XVF1GF59SFTWGeen+o1+nHoxZGVaqrupDK8zxs2y7Xz3XdyDRhO8LvqHRRsxr1mNpHep+F/aDfL73uutCKKneEAIkYb8FYeU3GdowY4wl7syL3+8DbtWM3AQ9KKecBDwb/Ac4C5gWfZcC39rYiUSYcVRNUbdRRaaMIRz1eiSCiyogieZUAVYGkk6z6HZJaqMmqZKT6DcIIpEqkHdWOKB9DlMDR6x3VrjCtKuSiiF8Xjrr/IGxPpXugauc6mavmvaj2qscrmYAqCbhR8H1eg7EdI8Z4wpikL6X8C9CjHb4A+EHw+wfAhcrxH0ofK4AGIcTkva2M+nCH/6NMI2G6KNt/FPHrUK9TCSck8tFs6KqvQNXgw7RRjl+dHHVBomq8YXq1jVFkppN2qHlX0vyjPlFp9GOqhq+XrUJ9rWMlQRjmo/drJeE22r2rJBD066LeF6Ckf83GdowY4wWvdO+diVLKDoDguzU4PhVoU9K1B8dGQAixTAjxtBDi6d7e3kibtm7T16Fqj6M5H6HyKlx1uwJ198gogRJVdhT5jEamah1VklfNPGqa0f5HOUKjyFvVeCuRapQ2rQoSvW1hn6gzpNHyqnQ+rHuUsNTrGOX3iepLfVayj3hVx/a+Fh4jxv7Gq+3IjQqziVTZpJTfAb4DsGjRIjkW2UY5YKNi86OEg3o8SiCo14Rav5qvOtNQ6j+sPpXKCtNEzVjUWYXu2FXbF+YVteVEaCZyHGeE4AyvTSQS2LaNbdvlY/rit/BYFMmre+ZEmXKinKm6gFOhzwIqEbOep9o3un1f7V/91ZWvEl7R2BZCxJ7kGOMKr1TT7wyntsH3ruB4OzBdSTcN2LFXFTGMESGYIXSNUidE9bxKYPpxPU2Uhh7uv6OmidJmo+qpQyVq3YSht0fNK0q4hPXTNXb1Gt0ZGqYpFApcffXVVFdXY5rmiA3qwvz1F52Ev1UBtTdmmajZhk70UQgFTFQbKmnvUf2hrh5+BXjVx3aMGOMJr5T0fwNcGfy+Evi1cvw9wsexQH84Vd4bmKY5jKx1p214LGrP/PB3mIdKIHoaVTDo757NZDLDhEmoPPvEZw4jn6iY9BBRBK+eK2uljDRhheSqkl6ZcD057JhqFvHb7SjmGYnjeFTXN/DOd13Ggw8/5M8KLHuEUFP7R21b2OfqPQj7OLxet/NXMtFUEhB7+ndk6Kber5VmBXrZw/LfN21/v4ztGDHGC8Y07wghfgycArQIIdqBTwNfAn4qhLgW2Aa8K0h+H3A2sBHIA1fvTSVCIoky1aiEp668hOGadPhf1XjT6TT19fXU1taWCa3S7oylUonBwUF6enqwLAvTNEmlUkhpIGXo7HUr7kypk1uU1h41e5GeBBG9f4xKkroWrAqK4WGfAHsWSgkBLz33PIN9fbj2EJ7nkUhncB1rBPGr+UZtJqfWL0p7j9Lyo65Xy43aXE/tV/V+6YJBzUf9HvGbaLwWYztGjPGGMUlfSnlphVOnRaSVwD+9koqo9uqoVbS6UNC14kQiwYwZMzAMY5h9WyULlYzC82FZyWSSpqYm6urqhpk/HMehv7+frq4ukslkJNGoduRKpqCwrrqt2RACyXASrXSd67qYwsCNCHHU6wSUt3P44m1f4+yzzsAwDTwPXLtQ7k+17lGIIm5dQFUi96g89D6rZPaJmg1ElVWpjL3BazW2Y8QYTxgXK3JVG72650z4X7U1wx5isSyLBQsWDCMH27ZHkIlOLCoxq6GajuObRkKh4du/fWHQ2NhIoVDAMBJs27aFdDpdFlDhdWEYp669quXqJOtJCcbItQI6iYVtd10XKYavAVDTSCkQgnLfOY7HQQcfgYdHfUOLLyBNgaeZiHQzilqPSqYpFep/XYCE/6NeCKPeG12gRM0MVIGi9mdUueX6EyNGjBDjgvRDqESvaoKq5h0enzJlCkIICoUCiYTfDNWRqZOtbdtlUjEMg1QqNSLUMZEwWL16Nc3NzWSzWSzLoqurl3x+iJNPPpnly+/jogv/gXnz5uE4Dp7n0dbWVibrsTTgcE2AuqEaEnADYpPSjxEJv4nQnOVY5iADCAkUCvkS05rqMN0cJx5/FI7r4SERgsg6qn4KtS9V6KSr30M9X/2e6OSv+y5CRLVRrwPsefmNfq5c5oirY8R482LcvCO3bO4IHKvhdyKRKn+SySTJZJJsNotpChIJA8PwyaFk5cjnLCyriGUV6enpw7Lz9Hb30dvbi2VZDA4O4koHu2SRy+VwXRfHccrfjuOxcOFCXNelvr6e5uYJLFgwj4MOOojt27dz1lln8tDDv+e6ZR/xHaTV1UyfMZm+vh4WLlxEY2Nj0BqPZDI5jOBCUlIXU0kp8fA/rvTKH4+RC69CAgvPqbOU4Qun7OCcT4Zz5s5k2oQkJ8xrpa6xCRcTw7OH5Y/nO4hHlFVhoVbYDnXRlnofo8wuui8kTBfOknTtXxecep3CY1GO21di6okR482CcaXpw0gt0nEspHRJJBJs3vIy99zzEya2TiWTrWVoKEexMETJHmJi60w8t8R9v32QpRefhydNivkSDz70ANOmz+SySy/mqCOOpFCyMYUAZ0854UzCsqyybb+9fQfTpk3DsixSqRSZTIZkMslxxx3HN75+Fz/7yW+49PIL+dytd9Devo2NG7Zx7733cvgRh3L99dfT19dDsVgMtljwSVj3Q6htruQLULVdVRMPrxtpFxeAC7hI6fHV2/+TKVX9TFl0MPmhQQzXxhMJn+SFYhKREiQjzGlRmnyU/V83EY2YoTByVqEKQlXjD8sZDZVmAXoZsQCIEWM4xp2mv4f8/IfeNAWpVIr7H7iPjo6dHHHEESxfvpze/gEKpRKmaVJX10BfXx+ea/LnPz1GVVUL9XUtTJl6AEuXvpMpEyfxwO/uZ+klF2NKEK5PBqVSCdd1sSxrmPlHCJOJEydSKpUQQlAqlbDtEp2dnXiex3e/91UG+gvU1tRy1dUX89ZTzmDFir9y7rnn4dge37jzmzQ3T2DevHkccMABZDIZHMchkUiU99nR1xGoiApbrGQKiRIYUu7xVzz15HP+BmlIcrkCQpZwwzBRb6TmHGre6spWXdsP66hfG5VGP6a3M8qMpPtb1LJUR/xYhK8fixEjxjgi/RB7CG2PuSGdTiM9wdCgxfx5izjrrDOpq02TTHgccMAsDlp0KC0T6ljxxLOsfOZxLMvD8wzy+TwzZ87Blb7N99S3voXT3n46jucOMzVUV1fzxz/+kXQ6SbFYxHVdSqUSmzdvDpy6fj2qqjLYto3rCC674kKue98tTJ0yl0ceeYRvfetrnPX28zjt1LdTKpX45Cc+TX9fjlWrVjNz5hzmzp3P9OkzyWQy5XaG6wT0/WGiHJ6VXhCjEqruTzBEhkMPPZyim2Rr5yCWLXGROCLYLVPuMY1EbblQiXh127tubgr7NSp+P8oMo2vsUQJCb1tUXrrg0QVTjBgxxol5x39Q3bKD0/8PQvjRM0KYfPCDH6a3vw/HKvGWk0/EtiSuazMw1E9HRwdnnPY2Lr+sj/q6ZmYdMInfP/A4hWIffb051qxZw4EL5zOUy3H5JZdSU1NDsVgsk0Imk+GSSy5h3bqXqKqqwTAMbNtm3rw5bNm0lanTJg3ieKIAACAASURBVJPNZMjlcrS3tTFtxnRcV/KRG97D+977ARKJJOef/y5OPfVUrrvuOiZOnMyNN32E++//A5s2beTYY47msUefoFjKI6XL2972NmzbJp1Os3HjRtLJFNKItoWrxOjJQMsVyh774SWeREiQwu83z4PurkESSZdUJsO6jp2cvDiB7YIhPVwpEYrGD5SjiKLqoc5IdNNNlMY9mplKn+FUcoBH5atHG6lpR3Msx4gRw4cYD1rQQQcdJH/xi18ED224KMhgxowZ5YgXGO4ULBaLgUlGYtu+iWYPkfirUauqqrBtm87OThKJBGvXrmXVqlUALFu2jGQyWRY0VVVVPPbYYyxZsgTP87BLFgDpbMaP0tm6jUmTW8lks9glP3InkUggcbGsIpIUnTu7+J//uYt169ay/Le/4Sc//hXXXnsZX/vat5k0aRJtbW3Mmj0Dxynx16ef5POf/2zQHhgaGqKzs4tMKlueXUStbJWKHT7afm0ADlIKbrnxaxx2xFxaG0wKuS7Oede1uLYHhjsiXxi5/UMlX4KaNipaJyqSJiokNFx8VelFMZVIXyd6faajf19++eW89NJLfxf2F/HeOzH2M2RoC99LjAtNH1RHoB8vP23ajGHhg6H5wTB8s00ymQx+D+G6w8nAMExMU1IsFpFS0traiud5nHDCCSxZsiQI13RwXTsoW2LbJZYsWYLrumUHrOd59Pf30t3dzcqnn+bss8+mUCiQzWbJ5QoUckVuv/02bvnEx2msr6euroZPf+ZmAEqlArV1GY459gRaWiYgpeSiC9/FOy46H9eD555bzW9+fR8XveMCCoUC1dW1zJ5dQ8IwsSyLHTt2kEqlhoV3hqYK09zTL1LKIAQzJF8Xz0tg20Xq6mowTPAMkznzF5b9Fn5U6NhcpArZqBlAlD8iPBcKikohnOE9V7+jwl6jNHq1LlE+AbUelRadxYjxZsW4If0QnucxadJkTNMnP5UYSqUSqVQK27ZxHIfe3l5MUxC6JkL7uDo7UFfoTpgwAdu26erqwp8NuOU0tm1jWU6ZaD3P33xt3bqXOPTQQ7niiivYvXs3hpS8+OKLzJgxg2TS5IorrmDixIl89J8/xruWXsScOXNIp9OseuZZzr/gbN566klYlkVz8wSeWbmKs885l0KhwJlnnsnKlc9w553f4Je/+jngCzQjIUgkEsycORMhBN3d3RQKhcj9bkKExB8KhUQixayZBzBxUiuGAWY6w7yDDkciyr6SqIVPw0xJyspo9b0B+tYMo5GqOiNRnc16BFAlM49eL/W/Xn8VI8xDsa4dI0YZ44T095BHc3MzyWSyHEWSy+XKZhjLssjn8775xbYxTZNSqYiUwzdnU79Dc89NN93ErbfeSl1dA+l0mmIxj2VZwwnFBVv4Mw3wSWPWrFkMDQ1RyOfp6OigdeJkkskktm3jeR7z589n08tbMEzo6xvAcTxWrfor+Xye+x9YzjHHHENTUxMvvfQ8By2ex//d8z/09Q5gGCk2b9pKW1sbt956K7fe+umyQDMMg3DCVtdQT0NTY3kPmr6e3rIQ8xwHQ1mY5iFIJJMUCxY33fBpslU1CGGSyqSZOWsuHdt34uH6UTvIskBUCVknVRhJ9GrfRmn/IdStKUbTyNXjUY5q/byu6ev1HVG32KwfI0YZ44L0pQTPcxDCxLZt+vv7SSQSwYIph0KhUF4MFGrhQojAfOPieZRDIUeaHHxhMnXqVGbMmMHWrW24rsttt93Gpz71KSzLKq/ola5XjmoJCSuVSpa13eamCXieR3NzM47j59vV1U06neTyyy+lob4F6ZmcdOJb6B/oJpOpolQqcfuXv0RdXR0//9nPuO79HySd9P0EBy2az9e/djtD+Vx5ZmEEDGUmE8Ps3olEAs/zaGppRrq+Rt/V2UHS9LejEIbANIL2G5LqbAuJtC+YGusbKOSKpJOCkuuHdJoIBIKkmRhBjp7ngdgzg4CRL7TRiVd38qq/9WP6Xj9R5procRJ9Trfh62Gd48FvFSPGeMG4IH0AKTy6du8mXyyQSiQJyVrK8CXldpkE9f1u/IVPJqY58gUfpmniSQvXdbFtyfHHn8jtX/4qF174DvL5fPkFI2V4gZ3fBaRBwSmSzlRRLJVIJhII10MYJp7tk/SE1ka++9938cSTKzj37PM47LAj2N7RTl1dDXZXNzW1tVx9zXuRUnLHV/4dx7Pp6dlNdVUVfX19ZLNZBnNDVFdXUywWSaVSOI5DxtizjXSojYdmq6JVwvM8WqdMxXEcdu/eDUH0k5AOa1ZvI5H21zik0/4saSg/CFIgpIEwDKTw9kTtAMNcQUa4RwOYQcy/vytc8BHDTTKqRj/snlaIxtFX0YZQZ2i6aUjPU89XX9yl78gaI0YMH+MmeufHP/4Rjzz6ZyZOnIiQIEzfqZswU5imSTJlIj1BOp0umzoMw0CGseEy2LYhaeB6lDdMA5+MZsyYgRCC9vadTJrUyvXXX88NN9xQJot0Ol3Wsh3PplAokclkqK7Oks1m6enrR+DPJmpqkpSKQay7ayOESSIRCh9fe7adkm8WCQRQKpVCSIOSVQD8+iUSCZAGJduioaGBVatWceKJJ5b39fE8j5aWlrIpKVwtG94zdfWsVSr4b8byBJ/59G3MX3Ag7ds30dDQQFNzLeede7ZP0DIQpFJisIeAHS0iKEpDDuP61XSq1q/PBnQHrZo+Kh+13Kjwy6jroqDm5Xke11xzDWvXro2jd2K8IfE6jd7xd36sr8vSsWMzhpHwPyJBOpslmUximibpZIrc0ACJRKJM+olEqhyVkkqlsPJ79l8PTT6u57F+/Xpmz57D8y+s5CP/chcfv/Hmcl6+8HAQnsDFDQSGb9v/wuc+xSmnnMrM2QdQXV1LOpXFtQUvvLCGefPmUSjkyGaryaSTFIIVvo5pgggcs0HkjWmaeIGvwDTNsk/CMPxVsIODgxx//PEMDAwwadIkPvWpT3DIIYdw1llncccdd7Bz5y6+/OUv09LSQm9vb3mG4jgOmUyG2roGP+pIGNz2lc/R19eHbdvcdtttuM5Ev3/MBFK6OI5HIojJT5pG2b7vMXxLh1DwhMIlYSZGOHijbO2jEbuqfat5qedV7V73NaiOer1+YVr9tY/jQbGJEWO8YJxo+ovkz376Y5qaq/ne97/LqmfXMKFlMs3NzcxfuHBPNI4nyxE8QPCik0z5d2gKCe3f5U3PTBNPOggBtuXR0NBEbmigbEoJzUEmAkfuefdqIpHg5ps+wmGHHE5/Tz+eEKTSafKFHAfMXcAZb3s76XQyMJns0b4ty6K6utqPQQ8Ej5QSUyT8EErPQ+DPXmpqa9m9uwchRHm1bkh4kydPJpFIYFkW27Zt4+GHH+bcc8/l+eefp7q6mlmzZjF79mzy+XzZ7u9H7xhlZ7dhJGhpbmHLlpfB9QjfrFWOBPKnJ/5vOTK80vaCyB25x1EeClmVoMNZwFi2el0oVIrY0WcHqokn9HOogiGMwFIjuMJxc+WVV7Ju3bpY04/xhsTrVNMH6Zns3t3D8uX3UZ1tYldnD7W1daxa9TwSqKurI5utLj/IpVIJgMHBfurq6pgxYwbpdJopU6bQUF9PXV0d4RukCoVCYNO3SSQS9Pf1YJomuVwucNamyjMDKX2Sy2QytG/dylf//RvYRYvu3bvp7Oxk+44ddO/uZMkRR1LID2EaVUhHkkhlcD0bN9AwS5ZDY0MdlmWVCTadzZAvDJFMpMnlh3ClQ8uECdx///28/PLL1NTUcNJJJ7Fhwwbe+c530tHRQXV1NalUiqamJq699loaGxtZu3YtfX199Pf38+c//5mVK1cyd+5cLrroInbv7gGSAYkmcF2XXV27EEJQ29hAbqC/LOiklIhhWz6E2rQozyLCV0Sm01kamprIZrPYts2OHTuGmVESInzJDeVjCIEbCA2BKDuFdXu9Lhj0RWF6uKfq4wh3SVXzMAyDdDrtt7m2lmQyud/GbYwYrzeMC02/urpa/vnBP1JVX83QUD+f/fTN5AoOVqFITXU9ZsrfisEwTRobGxkaylNdXR3Yvh1MM0l9fX35gVc3NQs1wJDcU6lUWRMMbee5XA7DMKivry3vsjlp0iSam5sxApKxLKu842ZIRK7r0trayuDgIEND/qsIa2pqqKqq8rdxDrRRtS6hnf6pJ1awY8cOzj//fEQ6jecEmqsh2LVrF8cfexzbtm2jqakJgEzKJzHTNMtO10KhgGVZNDY2ksvlePTRR1m4cCErVqzAtm2y2SxHH300U6ZNpa+nl6amJpxijp7eLjZtfJkXX3yRhx76ExvXr/Wjpnr7OO644zjooIOYNmM6k1un4AiXtrY2Vq9+ga7u3Rx66MGcccaZHLhwEfl8EUy/Ta4jkUF0lRNEWjmuRVV1NaaZpCqbxjDTVFdnSSbTDOV6kG4agYPtlHBdm/7+QXbt2sXAQB9bt2xn1+5OOnfuYPv2Dnbv3kVf3wBmEK3U1NhKMmWSzWZpbW2lWCzS2NhYfrlNTU0N/f39FItFHnzoYQYGBmNNP8YbEq9LTb+pqRHDALtkkUik+cad/8XHb76Bzp29FIp5EnaSdFUWyyrSZZfo6x+kqakleBlKwt9nprubRCJRfvmJ/9Yrs7zYKkRomsjn89TU1OB5HtlslkQiQalkY9su+bxPNADZbLZ8reM49PX1YQgZrBqeRmtrK5MmTaKqutpfR1Ao0NPb69vQA1+EuljMNE02b96M5To88dSTHHbkETz1xFMsv+8+7v6/H7Fx08sUi0U6Ozs58MADaW9vx0DgJdIYhsB1JRi+IEom0ySTaXp7e8lmsxx11FH09fXxjne8A8uyaG9v569//SveU09zwonH0dXVyZOP/oUELjnL31hu3pzZNNRVUSiUkMKkqirDtFkzOfXU05k2Yzq2tUczT6eypLIpJC75fJ5Upobe/j66e3aTCGZflmXR29dHsVhk86aNbN68lb6+Hnbv7iGfz9Pf34MQBvUNNdTVTKSh3hdmVdnq8uwtk6kCoFDI0dTcyLaXt3LORWfQ15sjk66hWMozY8YM6hsamD17NtOmTSvfw1QqxcDAAFJKBgYGAFjz4tr9P4hjxHidYFxo+jNmTJf33/sr7NCB57k0T6zjvVe9j3w+j2mmkXKPDVcKEyF8zTmZygRmGUE2mw6m/VBfX0+hUKCqqqocCqnahtXdLcNN3tS3WoX2cXWhmP7u3EQiQXNjE93d3RgJX+sMF3YNDAyQzWbJZFJMmTKFyZMnk0ymcR2LoVwOKaBQ8vcFmjZtGkJKqlIZ0skkmaoqqmqyzJkzh3wuR09PD/X19b4zO50u1yOcdYT1C00e2Wy2vILZX/fQS0uLrw0bBriWTceuTta/tJ6TTz6ZRx5/hJbGFsx0xu8TT2K7HoODg+zu2k5b2zYG+/vZtGUrXV3duFapLGiy2SzNzc3U1dUhACPoO9+mDtmarD/TkQbSkNTU1FAolBga6mfVs+soWt1ceME/UFfXQH19PQcuWsTE1tbAv+HhuQaf/dTtXH/jFUgvhW0JTFPgB0aFjttE2XGrh3dKKVm2bFls04/xhsW+avrjgvRnzpwpf7f8lzjB/u4GPukYosgXvvAFdnV2k8nUBG/Fskgm0+WQR1cIBCaZTKYcEZPJVJUduY7jUB1o4SHxh1EjYR5SymHbLySTSUqlUnl/n9CcE2q84SzCsiw/1FOxO4MvEEJncygswhe0CBNSiSR9u7txCjY9u7s566yzmLVgLtI06BvoR5gmTrHEYYcdxv3338+lF1/Cjo52tm9vo7W1lf7+fn9RmfAJ37ZtisUijuObrEqlAoODg1iWRaFQYHdvD6WSTU9PDz29/fT399Pd3Usmk6GpqYEXX1zL/PnzEW6Rqqoq0uk0Azl/5XNjYyONdbWUSiWqqmpIZ6txrDypZKK8OrpUKpHNVuG6LlOmTGHGzJlMnzGNvzyykoUHzuSOr36T5b/9FSYmudwguVwBKV3+9V8+yWFHH8C7r7gGYWSQ0sbzKAt4x3EwzTT3/eYhSnRw/nn/gGMbmIlgEZocGcYZtfr3uuuui0k/xhsWr7p5RwgxHfghMAl/xdR3pJRfF0I0AT8BZgFbgKVSyl7hM9/XgbOBPHCVlPKZMSqN6/grYaUAUwgWLlrIcUtOxTTTnHfu2/jzI7/DtUwSZhLXtrBkQOoeCGHgBfZz27JwgigO2zLL9vyQkFXHKvgO2zDSJYwMCrdd1sMHQyGRLxYwhUEmkynvv6/uFplMJunt7Q1Iy9fOfYGUJFOVpqurC38lsce6res5tHcJn7jqcxx77LH84uc/5wPXfYDNW7cAUFNTw5o1a3jxxRfp6+sjaSbI5XJ7tHvTd1pKKbEsfxO5cAfQoaEhf8ZTtKiqqsJ1LKqyaYQnWbhgDu9+9+UccsghXHbF5RxzzJFMapnA5s2bee6553j55ZexHI/BwX527tjB4EAfA/15trW3MVTsZcH8RVQFMwPPM8qEbRggDRPXtfjNLx7kd5tWc/45FzAw0IchUlh2ESORwJXwwx/9kO9+9yskTQPb8RAGvilLJMsmMcPwOOeck8kVByHYFtrwTED4W0qgbtRm4nl7jqnj6+81tmPEGG8YU9MXQkwGJkspnxFC1AIrgQuBq4AeKeWXhBA3AY1SyhuFEGcDH8J/MI4Bvi6lPGa0Mo488gj5xz/+Ael5mEmDUqlE64QpeB6UijaJpMfZZ5+KdG12d/ZTW1uHbVuks8H2CVIgSICQJFJpJf7bd3yGsfLpVMK3iUsDYRLs6eObcPQZQND2PS8whzKZhmGU/f39NDY2lmcK4XWJRKIsDELNM/Q15PN5Ojs7MU2T6dOnU1tbC/immp07d/Lwww9TX19PMpnk6KOPxjAMBgcHufe3y5k9eza5wSFKpRINdfXlXUSTaX9W4TkS8Ogf9NcfHDBrNsKQNDQ0UF1dzYsvvkhLSwvLli2jULRY9exKzj77bDo7O7Fsly9+8YsY+LOSqpos+fwQAnjoD3+kWMyTSKSYOnU61733aj7wzx+msbEZU3p4ck/UUzKZxip5CFGk+NSneGT7LK687ma2bm/HsSS2V6C2pgnHNTEpMX3mNNZt3EA6U4VlOWXt3ZWA4WK6AifYKE6N6y8LcmGDTOK5BiLYMlpfofuBD3yA9evXj9CGXouxHWv6MfY3XnVNX0rZAXQEvweFEC8BU4ELgFOCZD8A/gTcGBz/ofSlyQohRIMQYnKQTyRKJYvu7u5yWGUynaK3pz94yBMMDPawfuMGTj72FBxrA5mUwKARq+RRsHO4XoFUKkF/fx4hTLLV1QwN5WhsbMS2BcmAkIfyOQwR2OoTCaTnYTsOuZyLlIKamhps2y6/3jCZTGJZ/r76oZ3aJyQP5J79+s1kopxOCEEulysTTxg9BL6z2bKs8pu52traqK+vJ5vN0tXVRX19PdOmTWP27NkUi74pq7Ozk1mzZlFTVc22LVtpaGgglTQpWQWEAZl0uhzGecThR1GyCkxPzGDlypXs3LmTqdMm8/l/+yLbtm2jrq6uHIV04kmHcsopp/Dkk09gmEkKA0OYyQSFXHGPeUQYdHbs5KE/P8RbT34Lrivp6urkkqWXsmDOHDq7e/G8JJISyBQYJd+nkXD4yD99ikXp33PSBcvoGuwGL0nT9HqSrkfP7h5/ZmIK1q17GZEwsW1/IzhfbAmE8DBc34zjCYnhRWy25lkgkniei2d4JLwEUjh7vRjrtRjbMWKMN+xT9I4QYhZwOPAkMDEc7FLKDiFEa5BsKtCmXNYeHBv2YAghlgHLwF+E9Jtf/5rFixf7IXcueNIhX8z5Wx8YkgNmz2VzWztr123m3Zdeyrq1z1EY7CWVqcbz0jglh/raOoQQdPf2+JudFfLU1tRhOxbSMJBILKdI0kzg2R7SEQhT4DoW6VQ1Q0NDJJNJivkCRsIMCDowFdlmWRC40sPA3xLCsiw8qwSer+2HK2VDc09IQOFLX/L5PLZtl23+Q0NDZb/Cjh076O/vJ5lMkkgkaG9vp6GhgT/96U+8851L2bRpI45d8vf1sW1yA4PU19czODjIWW87k3PPPZcrr7mWo5Ycied5tG1v55e//n+cd8GF5fBO27aZM2cOd//wf9mwYQOHHXYEO3fuZPLkyaQSJouPOoSPfvSjHH30Ejp37KRvcICd23dQyOdIJlMUCzYzFsymo3s3wnaRwsBLuOAWSBoZXC9PU/0ibKeO+cdfzPU3f4dfHnUJSZkkZSfJWwUGXYe0J3HsNKbpx/BL159NuZ4NRoZ0UlIogYFEuB5G+Y1qfliu67qYyVoGiwPMmT6bHTvaEaaD6+x5yXowNv+uYztGjPGGvSZ9IUQN8Avgn6WUA6rNVE8acWzEkyel/A7wHYAFCxbIefPmcO21VyGl5I6vfY1dO7soWUP09w1SKhSYNW0q27ZtY+GCuYiEIF9wOPrYE9i0aQP5fIGqdIaibflOxXQG6bnU1tWSLwziWDZSGJhJf8sGL5lAuo7/MpTBIpmqWoQh8SybvFUkaZi4yGB1656tB5AGdskKNOJ8mdRTmTSO45BOp4ft918qlcqzh1KpVN41NIzXL5VKzJ07l/b29vJioqGhIYaGhshkMkydOpVcLse8efNoa9vKggULWP6be8kXhsqLjh594ilOO+UtONLjwT89zI033sC2tu2sXPksM2fO5Nhjjy3vCBres3UvrWXJkiW0NDVzxx13MGPGDNp3bOeWW27hiMMPRbgum9ZvQAiDhDCwSr6pCuEwdepUtrS18/EP3MDn77iFdJVD0qrGES6W5XDAnMNZuvQqbErc/aDgrIuvIWFmMRIOBUMwPdvHzlX/hTnvw6Q8g6JbQkoD4QlkUL9nPvdfHHvzUjyvGmEGi7psZYM96SGAfD7PVz7+MY455QzeeuaZIG0am1ro6uoqL7iTUo65n/7+HNuxeSfGeMNekb4QIon/UPxISvn/gsOd4dQ2sI3uCo63A9OVy6cBO0bLP5/Ps3b9Ot73/mUUi0Uee+xRCrkCrp3nhRdeYO4B83jX0oso5izfcWvCUYct5rnnnuPK9yxj5TNP8OJLz7F17Q4aG1pJJH1TwNatW2lpaQnCGj1caWMKQalQJJ1O0tPTgzCS2O4ghYK/OtdEIM3g3bwm5PNDOM6eLR2SiTSl3BAJw9/tUgiB5dhlgsnn8+VXN4bOVsdxhjmHs9ls+f0AL774IoVCgaamJjzPY/LkyQwMDJRt+U8//TRnnnkmjz76KJMnT2bZde9nw/q1PP/889TU1rJg4UJ/vYHrUsiX2LlzJ7NmzeKGG27g9ttvr7jLpBCCnp4e5s47gHVrN5DKpOnt7QdhYqRMdm7fQW9vP1MmTySfLzAwNEjrhIk89tQKCj19tDR1kcw0Yphp6qslXqqGhoYmPnz9BzntjGM4/4JzmT9vATu3b6FkDbF5azuG2E2fvZq3vON6HLmYZ1atBtdDGgKBxHECWzySp//zbg6+5hpk2kCwZxfPmpqachx+daqBf152DrOPOp3OQUi6BrlcrhytFUKOwvr7e2zHiDHesDeOXIFv1+yRUv6zcvx2oFtxdjVJKT8mhDgH+CB7nF13SimPHq2M6uoaufigIxCGQ/u2NqbPmMiyZctIGSBDZ6jhkjJTuFL4++hg8uyqv3LEoUeRSBhkapKsePKvtG3bwbq1a4OVu0PlMM6B/iEKhYK/wVoiicCPxAnDLweHBqgOXoruCXDd4FWEtoVIJMsmF0MkEDLY9TLYa980TZB+VE8i4WuYjmXjOFYQVWP5pqF0pvyeAKQBwl+5eujBi0mlUqxa/RwGgr6+PlpaWmhtbWXNSy9SXV3N5s2baWhoYNHCA9m0aROzZs0ilUpRXV3Lb++7n8svW0oh109tQyOJZJpnn32WZ55ZiX57k8kkjm0jAof1rFmz+NjHPkZVJkvzBF9LPu+888q+ja0vr2cgl2fn7g4Onr+I+YsPY6i/C9szsIsFiqUSu3btpqWhkb5cnp6eHu655wfMmjKNx594kndfdhFTFxxErruHwoZfc/lHfsCKF1bQv7NA0R0iIczAeZ7A9lwEJqVV2yiseYpZ//huCvkiuZKHmXDwXMG9997LueeezwGzD+TWW77J0OAmPnbzP9KXH8LApFi0aGpqoL+/H9NM4nrwoQ/+Exs3bohy5O73sR1r+jH2N171OH0hxInAI8DzhJvcw834ts+fAjOAbcC7pJQ9wYP0H8Db8cParpZSPj1aGVOnzZIfeN9nmDIlj2lKzFQS1zFIGBI/KMRjcKif+upGPCHwsACD51av5NCDDyFp+Iu3GiZO4P3XfZCO9i6mTG3lqqvfze9/dz81mTThdsL9/YOULLusaVuWRUNzk28eKhUwDMrx7uFePa7jUVdX528t4HhIYeJKrxyP7zgOhmdTtK1h4Z24/m6dngDb8crRPZZlkUqkEUJiJhMsXryY39//AK2TJlIqlRB4VFdnaGpoYN68eWzasoV0OsPQkB+5k8lUUVNTw5GHHcral15gUmsT9973IFW1rWxp6+SsM0/jgQd+jfQ8hPLCkjAa6cp3v4f7f/8AHR0dGIbBJz/5SSa1TqShqZGamhq+9KUvcddddzFp0iT+8shDrHrmWXr7hqiuzuJJh0UHH04qnaCKDI2TGrnowvPp6OhiQmMt6eoMbz3pCG760OV4uaex+gco5vr49YoB/uPHD+HmEiQMSSpZzUN/eQDL8k1ks2fPZmhoiDvvvJOB/hJ/vO8etu3cRXvHTpIiSaHkO7ZLpQKlks3AwBCZmmou/od3cvnlFzN/4QLmzZvHlZdfyQMPPMDmrVvwPI+hoSFu/NjHeHnTpijS3+9jOyb9GPsbr8vFWZlss2xpPoEPf+g4aqr8xVVFy6W/t4fTTzuDhx9+mO6eXcyfuxBPSmrrqkiksjz/wiomJBoP/AAAIABJREFUTZhEfU0jiaSkYUI9H//Ep3nm6RfKllYB1GRTXHzxxdx9990kM2lSqQxHHnY4Tz/9FI7099Kvr68HoFTIk0mlkdIn7ura6oCsPQYHc6SSaRIi2LbXMHBdiVUo4hBo0UG5juMg8fPI53K4rksykUYKj2Tg7K1Kp0hXZekbzCNdj2x1FUL6Wz/UVtdQV1eHYRi0tLTQ07ubhoY6qtIZckU/8mfp0qVMbJnARRddRCpThZlOglHDCccexWOPPoz0vGGGjXIEkuex5OijeeqppxBCcMkll9DS1MzCRQeyc+dOVq9ezY4dOxgYGGDj+s3Mnz+XI5ccxkGHHcKmlzaRFQ42krrmVm67/TaWHDGTqZMOYMf2bq64ZCnPrdnEOeeeyc9/8h3+/NjjTJ82kxVPb+SII2dz8aXv4dDFx7Bh80YShsFAzwC2azEreC1lNpvl2VVrePapRylJl/vuXc5Jp7yVww45nI6O7axZ8zwLFhzIwQcfzEUXLuV39y/nLScfQ7FYIpOtpbm5mYMPPphbb72V91x1JR//+Md5ecPGeD/9GG9YvD5JP1MlDzpoCW3bVjPvgAV0bN9J0c3R0NCAaSapq6vDcazyYiPbtjBkkmuvvZoXXljNt7/931x19bs55PBDWL9hE9/85n/iuWY5ciORMMrbI0yaOMF/wXkQASIBz4OLLrqIZNJky8aXcewSpmn4LyRP+O/DtW27vACsur6OdCKJNAS27VLMFZGexabNW6mqqcO2Xaqqapg+rYmWlhYmT55MfX09U6dMo7amhp/9/Ofs3LkTy7JYt3E9v//DQ3zkQx9mw6bNLF68iPPPu5C3nX46TU1N3HDDDQDs7NrJeeedw+OPr2DBggVs3rKNp59+miVHH86sWbPo6RrksUefAmFz6OGHsHz58nL/qqtUr732WtavXcfza16gr68PgKVLl5I0Exx2xOE0Nzbxp4ceYmtbG1JApirNrq7ttLa2MKGlhc3PPsvFpy1h2zOPkTxwCc9s6sA2DegtkRrYxmDdRDoHBzhp8RHU7VzJzx5p5+3nHcVDL+0il+/jkosupyHYGG3G9KmseXEtbVvbWbT4YF7esJ6q6gyzp83iqRWPsur51dzy+S+wbdPLWJbDuvVraGlupbd3kKqqDAlcXlj3Eme9/QwaayZR01hNJlPF8uXLqaup9WdxjXX85J6fsq29PSb9GG9IvC5Jf1Jri3zvlZfiyASGEKQzBqaZJVOdpZS3SKazJFMCIT3yxRKZTBrpQDqdxLJLmEaCwXwOy3Lo3NHB3T/5UfnNViDxd/k1qa5OU2vAhGnT2d3bR8fOXdTU1DA4NMgJJ55IS1MjK59cwbSpU5g6dTKTJk1ixVNPMnXqZObNm8dJJ55INlNd3uLAD3+cx0svvUQqbVBb18DFl16B58H3vvc9skDB8hdjNTY3k0il6evpZvLkyWzfvp1kOkVb21YeX/E017znSkqlEolUklQiieMWyWaqSSQNBCaXXHYVy65bxhlnnMEnP/lJjjzqKDp37qCqphpBkpNPOgG7MAjC4+ZPfpY5cxeydt3aPTMeZbdP6Xrl/e+FEJxzzjlMnNDKtBlTaaivZ+a06di2zVXXXsPCo2dQnaylq2OASS0pjp6aZbbTxWd+1sZNlx3EL7ZYPP74Bi49Ziq/fXI7bzm8kT+uH+K4w6dTtWMT8w5cTCLfyS93ZdjwUhuLF83igovewVMrnscoedQ0Ztm8rY2u3T1MaGnCKRWZNHsGRx92BLlSnpbaZrZta8dMpnlixSO84x0XYppJpHQZ6M9jJJJMmTSV7p4OOnZ1MW/OAWzdvI2aqioe/MPvedvpp/Ltu77Pru7umPRjvCHxuiT96dOnyo986IOk0oKE4cfBYyTxpA2uQzLha+WCdHnFrB8HT/DGJ4Fru2SzGdLZFFNmTub0U8/DlZKEkcJxPAwDWoRDswu56XMoDHXT1dcHEs459kR6hc2UKVN422mnUl2VRkiJVfLDLtWN1wzDgKRJItjp0sTETCWxiyVKnsMHr/8oQsCXv/wVJrc0BBE8LqYZ7Odj7Nm0TRoGv/7Nb7j+wx9m69atvLxpEzNnTKcqnSm/FAWgaNvMmz+f5557joJVIp1O86UvfYkTTzyZxYsXs2PH/2fvzaPsqsq8/8/eZ75jzUmqMocECEhCEBBU5qEBFRQUW5wYGhu17VffbhFth3ZAQW21tW3nbhtFpRVHQCYBkXkIEAiQkDmppFLTnc+4937/ODcF/rpXa6/1a8l63/quVetW3Tp1761bu56zz/N8h1F0mvDSI48g8HyKpSqtKObNb34z8PxO//jjj+euu+76PW/6c889lx07trFixQoG+ns58rBVJEZhG4FXLPKZr3yMD//tx+g0EzzHRRhFFkVo2yNKOpTsKr19JX5x9WXcfPcoX/31vzE6IbEJEcJDphGhFljGMLR4KW97y3m89aK3snLxYcQ6wREChMRIASqnYsYqe0G6mIPreWAUOn0+B0ApheI/Bq0YLZBk/OT6H/NXl76Tu+7/Hddc+yP27Nk7W/Rn8X8l/rtFX/7hQ/7nUS54vObE1Rx54EKWLuynx5M0pyepBBUcr0S1Og/XrmJZNlEUE0UxQkMWKzphQr3WoN3pMDExyc7tu9i+dQffv/YaRobnoLIMRMZfvvtdHDCvj814BIHADxwQMGfOIOueeIx5Q4M8cv+DaKVotTpMTteJ0iRPjrIsMmNw9/X6laHRaIOwiZWi1WrgFcssWnIACxcuAiQf/OAHKVQqDA0Po03eKpIGEpURZymZ0TSaTc4991w2btxImqasXbsWKS3SNEMLQZQmJErRarfZsWMHDz/8MLt37sJxHK644kOccPxJ9Pb2csYZZ7BixQp+9MPr0FozOTnORz/yd1xxxRXA88lSd911F0ceeWT3ZJIPUJ9e/ySVchGdRixbMIJ0ob+/l0K5hO8XurqBDhJJGEZEqcbgEcYhcZRx/tsu4Hv/cDmtKGECwc+++HGCRBCmGSKDJLMwjod2XBwp8MoBBx64AoOi4ARIy82zhSMFmSLTGY4QyFQhtIAsJQlbFLwCfX19+L6P67qUSiUqxfyj6AczH4EvWbbiQN70529hoL+PTU8/jWO7L+r6nsUs9ifsF376mzds4a8uOJO9Y7CrAfPnOmzek/Lm17+eJS97KWmU+7TbnovluZhMkagM3d2tplpRqVQwWW58VptoMn9RD3OH5nDC8a/gl7/4Nd//9tcxrmZguA/LkQwMDaGEoBJUaXkux77yFRz/yhMAZvx1tNbYrkNtuo7ruoQ6wrFtpOsQFEpImatyo1jz1gsvwnVtkjT3f0nTlHPPeyOB5/PvP/oRE3vHMCoFciOxLMsYGhrixht/zfHHvQKlFIVCIb+asGziKMK2LeI4oVKpMDExQavV4rjjjmNkZITPfPZzvPe972X37l1ICatWHc7KlYexfv2TTDfqbNmylauuuorPXH0VH3j/5UB+VfTQQw8BuVPoVVddzTe+/s8kScypp56KShOySDMWT1HQEIoaliVzxkw3h8BxbNDw6ff/DRW7yMGDFq9cVeKmBwUWE2zaNMVpVY3f9rElJNogoiY6jhkoLEM6klajia08VNZGGIV0bGzHye0r0BT8AlmaD9izLEMYTaPRyAViluzmI2hsIX/P3wggzRKatTpTU1NMlEtc8IY3smHrP/ypl/QsZrHfYr8o+nP6BK89ysI4AaMNG5WETKpBXnbYAeyI2ki3kIt2shRhWUhpkaTxTPqVJcCoDMe2wRgEhp3bdvDWN/857XbImpWrSS2H3sClp7+Hb37rX9BaE4YRe3fvJUMxumc3PYUSw8PDdMIQt9vO2bjpWX590624QYFqtUqn2aB/aJC3XXABQiXUGg1GliwFIYiT7Pd+L9t2SZXmig99iHdd9g6yNEII0/XZ9xkcHOS4415BsZgnbdUbNXzfy9scWhN3kvx3dBwwhjlDg9QnJ8myjNe+9rVc/oEPcvLJJ/PrX9/C619/LosXL+V93QIvhABj+MD7L+fmm2/m17/+Nffddx+WZXHuuefy859cx1e//EVWrz6MM844iyxVJGlGqh1UGlLxBddd+22klZvBGeGCNmitSLE5fMUh9JTLvHTFKI/cu4EFwy9j0HuadTum+On3vsGRp5yL4zuYNEEom6996G84/13vxpIaFadI6fLNb36LsNnAxAl2rBlZuog3X3oRt911J/V6jYmJvYzMm8fpp52ByUJMZtAZSJkno4VROKOT2GeGNzJ3AZ12g1/+4qf81WXv4e3vfDd+qfRiLOtZzGK/xH7R0180IM1HXy1JpUdH9WKbhCfHLE486TJ2GknBFcRxzquPoqhrqfx8aMa+Xrtt55mwjuNhIcGSeH4BaRmkFWBLEI7N3vE9LF28mK997WsYI3nV6WfRSUOqPQV0YsgyjRYaaSSV3grDc+ayY3Q3GBvHNZTLJZYNGL7x+U/jDPTyhrd/gNPPOB8tcyM2sBBGYMgzZl915hmcdcbpWDYYDVmiUKTcfttvOP3UM8lUiFKa8fFxent7SJIEY3LaZ6fTYctzmzh09So2btzIyMgIhUKBWq3Glh2jbN68mT879QSeXPcUS5cu5eHH1vHoo4+SdFOoACzHY+GCefz9h/+OOAopFEtoldFsNrvitFwwZgtBZDS+sHj21h+y8tAlfPbmO7n8XR8gbedGxpZlIYlxlcdvb/8hJ87ZzaPZ4cxbspIoiTlmzbF88rLX8Hef/yLP1XO7C2KBM7aRWx97hAe3b+CSC95Bwe9HJyl+2WXBwhE++rGPs2nrbgolwwVnX8DNt/+GD3/iCp545HF2P/ssCw4+kFLfIFO1aVYvWo5VDJicbtJbKTMwMIAS+QykOd3kmh/8K+e+4S3cc/fdBOUCP/7xT3j22f/osvmnwGxPfxb/0/j/3WXzTwFjDGmqMG6+m683x9m+HYRtITKIwwhEnhhVrVaREsIkplwu47nBjMlZppIZT5skjKjVG9idvEWgMkmctMBY9A3287nPfYGBgQEwkp/f8CsOOOAAesouaSdFuh6tuI3WeavnggveyPqbb8WSHj0DJUZGRvjav9/A4adcRH3zb9m8YQO9PT61RhttQEqFFiA0OJZk9erV3H///TiWjcxgeP4Q6595mu27dzI6uQtfOkzXGliWxbZt22esmSEvsnGqGN87Rn+1SqdWZ/1jjyNti7Ne91ruuutuatN1pqen2bNnL9VqFdd1ieMUaVkI2yGLO9QmxpmemsQSJufDF/NIwjRTqK6DZZIkWL5HuxOy9dlHEG6CbdtUe/vJfMV0rQ5CkCaGCMMRywS/vXOMl1z8ciQuvb5k0+gOJkKfn3/nK6x57eWERuE7kvmr5vPQ17+CWjiCcHzswEMpTWtqip+sXcexx5zI9q3XMVit8LPbbuG8c07nwrdcyoUXvYmhAw5g4zNPc8hRFVzX46FHHuSLX/06I0sXc9QRazjpxBO55977ufCSC0mVzbmvfx2V3j527NpNojts2bL1RVzds5jF/oX9ouhjwGhJmmjSJMKxoFTykH4J3WoBAtHNh03jmDAMcRyHqaSGETWiTgjkU+l9HjmxyvCDACkEUdimXKpSqfQxOVXjyiuvRBub3t5elFJMTU3x0CMPI5Tida86i1hnpEZhlKJa6aE+OcGT6x4nTjSDc/sIPJeylXDDdd9h0byAB7bdzJGHH8pkLaTR7mDbkjBqoZXF0NAQGzY+wymnnMJNN93Ew7+7i5e0YXr+HBIluPGmW/CERTsKabVaVIql3Okz6iCEwCsUmZycZO/UNAsWLOCOO+7g5BNP5DXnnMOixQsAyfXXX8/Y+DQrDzucbKKOSjNsNCXXEIUpUkCWJnzuc5/jPX/9v6g1W8wvVTCWxPe8/E9gDMVqPyoTBMWUNUcdw4NPbEK70OzEZDHEmcJ1bVJRxnc6zHFHWfw3/8j2RoS0ArIsQbiCL/zrz/nm+86gQYhrB4xUAyZqIfVpKC+08IMAZQky10G0YfXhh7Fj81b8ssclf3EZt95yG61mxPwlCxhevBTHkjx+99185sqruPDit7Nw0TAvP/YIXvKyYymXimzevpUnn3mapzdspMevkqiEWms7SinecP4b+cXPbnixVvYsZrHfYf8o+gKUlnSShOc2h6xYQi61jxVSWnheQJwZpO2g4oSBgSHSNEZjKJfzna1RGWjNrl270Cr/ecfxyLIUx/VJshQVG4bmDZGkIIRifHwcyMVbp59+Gk+tX0dlsHfGriBLYnp6+hjsr7Js8WJGx8boRCE7R8fYPjnFISsX8+zGjVQWLQdj45XbsHMHtuUwZ2AO42N7WTyygG3PbeYf130Rz/NYedhqbr3zTk6av4aFlRKZSXl64ya2bt1OGEYMDPSyZOEiBgYG2LVnNxO7ahx00EGkUUjgSw46cAmPrn2AR9c+gNGglOLlxx3P5FRtJl3LtcEOLDCK3h5BqXcBy5cvp1wuc9+DD1Eq9zI5MU2lUqFSqWDbNkIIpp1p+kp9VNRuXnHqmfzo+r9FrxihNjWJaxdwHIs0ivELEqe+hxtue47jDrJwHJtOs4HrFzBRwvotz/LwTs35/X2M7mmw4ZmnaHfGGJ5r08g6TO7ZRaV3LlE74bltW9l8/U9ZcOiBnHzcKShjmN67h6GePj7x0Q9z1ee+xMUXvY3Rbbv43+99L3fc9Vt6XnE0r3jFsVTmzsN3CzTrNZYvX8DE2B5UkPCzG6/jz998MUcfuYo0Tv7A4pvFLP7fwv5R9AGFQHqSA5Z6+K5k0cJh2ipXywrXxZJgC4HtBoBBOB5Ca9rNNh3RIUoiwjDs5txm9Hd7434hYHR0D+12Hc8tEYZNpHARUs3YK1iWw9q163j5sUfRajXwfR+jPaTtsHP7Zj79yY9TKg5S9H0ufvc7eXL9kwz2FYmbTR5cdwenLz6CVnuKTr1NyQnwPJfp1jSNVp3JqXFed+45lHv7mJiYYNWKFajJmDe9/gL2NKcxScbpZ52NEGIm/LxSqVCvT2PbLrt372ZsbIz165+k1mgyNHceBx68Ei/wmRobx7Is5s2bR6FQ4L7f3c1hhxzMmlUHkWUJSuVDziwKabRbtFsajaA2OUG5UmByb24FXS56eF4AUtKpTuCFT7DFm8+iYY8NAiyd0Jys5yI5SxA2E+bVb+W4Cz9Fc2IM4xqQBtWJMNpCqzb/8P0f8M3L38kJ7/hrbv/GZzlw8Xze+NZL+MaNv2Sgt49CwUe5HhvXdzjr9LPIPMMTDzzO9scSHCRbnnuKW2+UvOHc13D3Hb/hqKOP4N++803CTkZFQrWvwhCGctDDj398LUcd9VKSqM01P/8Fp532Z3zyUx9lwdwFDA2PvNhLexaz2K+wfxR9k/euw05Ks5WQliUTe/ayXFjYlkuaKVKy3KFSZySZIdMpRml8p4BCE6cZRghSneJgs3PXHuIsIUkj0ihFCkWWZZTKcxDSoJRBmQyhBSpNeftFb2PpooX86pc/wpFlmvEErlNEq4S5vf145X5UK+Szn/gIJ512Bk+svZfJ3aPceMs9fONbX2LnzinK0qcpNHGzxmRtis70FLu2CG748Y9xXZ/RvXv5tlaYzPCRT30sD1S3cibKvlD2fW45M97xOqNdm+KUE47HMQYLhWo3SJMQKTPmjsznkksvJmy3OfPM01E6t3nevXsXlUqFarWKSlJsz6darVKfHueXv/wlByxaTqfVpFQM2LJ1KyqNsF2PZm2CpzduYlPRY3jNWSwZ6uWkk/+MTqvNQ488zFNPPY3f3s59ax9h0UmvpFxyiDopxrHwbYckSxHCUK89wdTENGJqnJcsWcbU3i0cffDhiBt/zC9uuJGH7rufs848i8XD8xlaNpfPfuqzLF44TO/iNSQPPc55bzmPvuFFfP+H/0KPP8ju8XEs6XHZuy+hMz1GoVJFeA5Vf4Bzzz+Pbc/sQqWG1WsOpt6qcdll76BQKFEsFrnpppte5AU+i1nsP9gvir6ALivHp1q1yVSKV3CotyfwXZvAsdFJgis9irbIw7WlwAhFUEiZmJjCjmMqBZdQZBgMmavoK3hYwsNyDbVmBsJl79goRqdYwkbr/FghJVdf+RmMVlzy1ldT9TOELJAowa4xwBdU+wKatqCfRaxcupy77ribBfOGWfvYAziOx7y+YRaO9PPEus200ybzqj30BgWU0URxhyhsolXCtu2jL/i98zYSMBO+IqXECCj4Qa481Sl/8ba3oFVEEAT0VHq6XkQZyIBCuZ9vfv0a0iRizZo1TNdrJHHGdK3Bju11ENtIophU5WpW17YYnruM7dueo+AHhJ0mPdUKfiEgCDwcIXn4ScPyNSvZsnk9tSef5QPvvxwpJSMLFvLzX92Ut4Ssw7j+n7/E313xQdzeCnGrQSdJZ9LFbNeieOBq5Na7eOnrX8X3/+ErrF23Fik8zjrnXO5/aC2vPP0EnnzyObaP7+ENF17INd/7DqdXeoiNYfu2bdx8491MN8Z51cWv45afXMshhx3Czbf/hqULF7GsZ4Ql8xexedNzFMtzWbASLFHi1p9cz4EHHswNN97O2O5RLnvnO5DyRSHuzGIW+yX2i6JvAN/3QStSpUiUYKg6QLvRoqETfMvDcl06E+P4nk2pUMCRDpmG6ak6xiiMEHTaGUp4RCpF2C6tJMJ3PdpTHVxPgqkzUDG88+0nkuqEqUaKklUCv0LarrN542biOGW0vouhgT4euP9eZHGI3nIPF/7F62nUQ7SIaCcZp55+Mrfd9huu/fcf8i/f+j5Xf+R9bB3fjWNppOvkUmet8TwbW2ls28ULfPa2OjOMo1xkBKJrK2Dbdj7ETRIsIdBAkuYU1TBuMrG3QaM2zcDAEGEYYbs2XnMCL4BiyeO399xCFIb4vk+lUiIIighhKBQchJVbWOhMoZKUan8/paDUDYvJLSKiSFOp2Jzx6jdy82N7saVFT6kIdm5e5zkuPaUqFdcB1+B7BYrFAIFL0RvAdX0yk4vPkiTh5Nf8OT+4+gO8c2CEului0DuCRvHda77DxZdcyPielEatzpIlS/Ckx1vfcjH3PvAYLzvheHr7S2TZZpYfcDAf+tCH+PAVH+QTV3+Ggw8+hFvvuoPf3nsPSw5YyGvPej1Vz+eaa27l0osu5JxXn0lv/wCLFg7noTatOr43q8idxSz2Yb8o+hgQ2GRh1M2jsxjuLxL3VDGkGJ371w8UBonjmHYnw/UdOp2QThQhlMYkDZrNUQb7AvrLAXMXL2a8ZjG6u86e0d0IS2J0guc5DM9dxkDgMXeOje0HqDQmCTsM9vYzPT3NyIIDQcasOGwNj699lnkVzfbNm/jyFz7BWaedxVHHnoy1dCVzzhvkyUfu4+7rvsXHTj6HvasP5m8vfxeOZdGOI2zbJnADpFbEYUSqstzZU6ncvH1fwPe+t6GrO5iJZxQC3/cpFotkSQjCxrZdolhjOwFhJ8QvufT29IFRHLi8B8gFa/uG0fnjakzXm8YvemzbvAXb8+jEYDkSS0OGi+0apOrQXzS0OuMUrQzHd4mzDG00URIzMT3B4LJFNNshFpKwk1FwAlIT025P4vs+7W5yWBwmvOK1b2XnlocYn2rw9LPrEcLh7LPP5p/+4avUag0++8EPMs/voTkxyUJR5JYNG7ll49MMzptDrdHghAUn8LEPf4TPfPYqavUmD91/P0JIPvPJj/PAg4/w+OOPM2/OXB57ci233D2PVQccQths0Vuu4HkunU4HKfYLt5FZzGK/wH5R9A2QZQklzwIjKRZ6USImSSL8wKVQKJAkHWq1aVSW4oiM+fNdHMumMd5i98QeRKnEksVr8Pwe6mHIc7s7FAr9jCyYg1/tx3Fc2s0Wnhegtea5LZuRQqPiDkkao4ykHoYsHQiYZ4/RjJqU5s5l0XmvYv0j9xMEDn/9t+/ny1d+li31lGarRtl3OPqlp7B3zyYmDy9RUgJHucRpgq8FShjSNMYRMrdU0BmloICUdtdeIA9U8QIfx3EAyLTGdV10luTZsUKSJgph2RQ8nyAIkFi5CM2z0cJgjEIKg5SgEbi+hzEaEBijEUgEAq0VWZbS01slDNv4gYVtSxzboRV20KkhDRy2bLgXI/uwuznBEoFlWxilsaRDoaePerQTz7LRJiXNWhgsKuUyRd/PBXMqIfZTmu0Kv752PW+6/DIe27ibKGpxy803M3feILXpBo9tf5KvX/s9zjnvLG64+Va2bd7Ga199Jo1Gi+nGFKPbNvHxG37FQHWIgYMGWTpvIbumazTbLY49/mVkYYdmJ+V/XXopCIVXLCGiGBuDb3t0wvpMsM0sZjGL/aToCwFohVAK4YHGIm3FHHPwAFOtGvX6NHv27gLj4DoeluuzZ29IbbpBFIPrLiRqd6i39mJZk8SdCCeQ1Cd3MNBXwokTrMyix7EhS5huTNBX6lAMCnRaFkJW6HRC5vT1oIVhVwRx5NFfKFByfZYecBjf+/41NJtNBobnUtv+NDYWNU+wbsN9vHLTOtbeez3z/+4rNBNDGLaoFiqEUQsbQaYjfN9FRpI4VZTLBTKtUVlGUCzkoijLIo5zwVmqNTozWJ6DMRmWa1Hx+7ClxLLyVottDFoKlJFok3XfRKt7pWQQQqIVSOlgUHn2rRakQlIulhkYmpPbGug8v7enVKadGJSI+Py37mTN6WcTElOwfSxjyFTOdnIsweToHhzh0TPYx/euu5aVi5cwf9kSjjx0FW6pCCajXYeGbjNUrRCUXMJn7uWUE97OA0/cx6tedRJZXTD4F/OY6iQkG54iiQWnnHouUbNG5lrM65EsE5LASFbPOxgvTLClIW7X6ZGasXvuYcGJpyOETyAk45NTHHTISpSQWI6FBpQw9M8Zmt3pz2IWL8B+UfS1hkwoHNcjylJcD1qtFg9taeMXSmRhRGXuSoTbH9RDAAAgAElEQVSO8x2x0kRRQv9Q7qkSxyGDcwexLYdO2CaKWjQaHTyvxJ69TfIkPI2UhjAMabQipBY063uolkvEKiXwPOzEUCqVKDi9DPYUmZiYYGhwhKH+IfqPGWJibAwpDEmq0IGF1YzYsHGCjz76JP961dco9/o4OkW6JToqxrFcojBCCIXjOCSZnolXtCwL3Q12UcaAUhSLRTpR3hYyjsCkCSjN7tEpjn7ZEbQ6LZRSuL6fRwGGIVmSoTSkRmGprCtOy99XIXInTQGkwuBICQY6UiMTk0uGNQS+jy0ETuDgZhZHzemlk8X0FApAnuOLFBTLJVphh0xUMVrT7kzzV+/5W5xiPw6K9c9uwTIaW0M1CFg6MBfhTHGvn3H//es54qw8J8BqRTxz9xPUFg+wcGCA449azoZOk7izh95CiWKxD9e2CeOYKOkwsHyQOI7w/ACpR1hgBxgkz3UmkdqiWCwydOByWraH47mAh40AbUBr/nsi9VnM4v9u7BdFXwqwtCTVeSPiua0TlJwSqhOhRAHXdojjEOF6SMsh0zHFYkC9XieOUwoFn0Y9jyRUShFFMY7jkyQJju0ilM7NwlKNjjOEMkjLYXDOHIQxeFIihKDRapN2EhLRwul0iOIWett2DIIs0xSLAY5rYysDrkWx2scxZ5zC0Ws+zy9v/BmrasOYNEMZg1CSTKd5q0ZnhJ2IJGWG3ZIlycwgV0qJ6frCSylJ0xRXWmSewCjFykOX0G63mJ6aYuvWrcydN8yc4XmUsJmOI2zbx+iMVBgsAS+scbm3ksE1AmU0jjHITkosGmzfvpM7bv8Nc+bMo6+vj+GRflYdshSh28RxxKRUVGwnf31S5ElilpW/l1FCwa6wwK9iRW0yx6Y4f5hMG4zrkiUhu5yYsbW/o2kEkxOGp+6/Ey+16QiLQ046HWVq9MVjyHlrGKx1SM1CbANZ1ka7NoHvI5KY7aO70KnN0NwqAwN9WCiyWFHPJL5TxJa5uV0QFJGulecYG4NRmjQO//QLehaz2I+xXxR9o0GqfDcu3DIDyw5lYttWDlm2iPGp3Ui7yvZNO/B9fyZHFa1J4gxDSrPdznvkMg87EQZ0pvAcN7dkDlyarTau4xD0lDAd2T1Oo9IMjUFIw7y5A2glsR0XtKCnUkbIfKhqWfn2udVpU5AWaWyRpAm/2HAjj/zqft7zof9NaWSIWGhi08LWFpZjo1KNtC2UAonA8zTCGFw3f23StiFNZ2yEsyzD8zxSbbBj0Mrmll/fRaXo8rKjjmTx/BFKlTK+LTFFH9KYOE2RDmBAq32iM8CY7nBYkgqDq6HtgbtljIKtWKYV7qqD6RkcpGewn2JlAL+9B8srIKXE0wKEQBuByjKksAgKJVTUxhgXY9nULY1TnoOLoNWcYu/oLjY/8Bt21aa4/6kN9EXwl+96K0ccfwbf/8TbCUOHSrWA1jaOKnP9T7/Dq9/+PgolQ9rxAdCeTWYMlpAYYVi25ECUSkhVRpTGeeZAllKSkom9u7E9h1KlTNQB01HYXSsOIwXCFrM9/VnM4gXYL4q+FpDgkWpJGob86t57OHP1fB5/fB3/+KWvct2130aFc8iEy9y5c/EDF0fmPfBUp9RqDVqtFu12myDwqMwZRGhBFEW4WpFGIb7n4vtu3jfv7wdhk0QpVkkgumlcluWQpjGWLclUhDEJEo+w3cH3fRzbxnUctABbS0I3oqp66J8/xJV/fyVX/tM/4qkURAnLVWRaoY3BZCBsm0a9me+EhcBzXBzHodVqYVnWzK4/30lnaKXB9VFJxGtOOoGK7dCoNemLLES9wcTEFmqNaeYfs4a9pBRiA0iE83wq1gtth2WWM3isRKFWLaBpPAquw7y4je96aK2ZShXt++9kT5yiOgkDA7kFtDECY5MXUZWh3BIyVvhqjMev+RStzObCT36WejOht+JR6TzJSw5YwZsu+jI3fOr9HHXCK7lv3ZM8szFj+XCM0B46ixkQkpHDDqMTR/gDJYwQtDsxJsuvetpxZ+YEFoYxrXqTvh6B8ew8Qc3zGBouEqUJlmPhB2Vcz6bTbLF+/VP09PTQ19eHfEFa2Sxm8f869ouiH2ubdTsLtExKrZ5xyiFlZNzgsVuu4+VLAr5/1Qc59PQ3Uc+ibvygwXMD0lQhTC5oyrIERwrCVkjaDvG8nEXj2C6WZeG4HkqD5fmkKiWJ4zyAQ0nKxVK+09aGoORQm2rSU+0niTvU6h1SYzCZwUoljteNDMwSSBUnnHgs/b1z2bjhGr748b8nNGDiEO1KhAEhTS4OEhIvcEk7CXGaEnVpjUII0HqGtZMlCZkWWFoRhx2iNGRCa1oCZH+Vtt+mWirTd/AiekzK3rFxHNsh0hohNLbq8vF1/rx5KAuAJDMGozVWBsKE+EWXFctW0t/fT7FYZNOmTVz9yUe54IMf5dobb+OpDVuZN28OixcvzucNcUKiFXYWkRiDp32e7WScfO6lPPrkdkb659JJFISGbVs3MnDgTkwn5LYv/G8u/ty/stT7K2751Y+JVEQ5GOSp+37LotUvx7eK2DKg0annw2I7L+rGGLIso9lqEbc7NDstEpUyMDBAtVpGWBKVaQqFQp47oFOSdoqwJAe/5FCyJFc5K61e7CU+i1nsN/iDRV8I4QO/Bbzu8T82xnxUCLEE+CHQBzwKvMUYkwghPODfgCOASeB8Y8zW/+o5Unx2VlaRhTHOfI2SW2kaiym3zNl//hZG77uDJEtzf/tiJe/bhwnFICBKRc5/76pbjZHEKKYmpyiXyyAEKs2PNdIizTJSy6Kvtw9hFJ50MSjCNMJEGmGVGRoZoD49RVDuoVooEdgWSRYTZQohDGW3wJtOfjXRczt49pd3sFtPsHzzJIWBfoxRZI5EG4NrujYLRtLudNA6L2I6y3BdN9/dC4HscvPTbjpVmuazAAuI45i9Y7sZHh7G8zx838GQoZTG8T0c3yNN8+L2PC8/H9Jmme6+J3qm1WNJh8NechilYnHmCsMYSasV0tM7wEdv/A1WCNdffBmnnnAa47t3M7V3L7bnsuaIoxAqI0sDDBG2CXlpfy+3f+UqLvvrv+Ce7/+AtNNglylydL9g9O5v8sojKyR2lR/8/bvYPdqgGVSwpE/aSXj8gdt42UEH4coYt5kghIWUuf1EkiQzYjUhJaZUZHjBfGq1GmmmmJis4ToOju3hKhCWBFKEeV7nkEUhUZLmV00v0tqexSz2N/wxO/0YOMkY0xJCOMDvhBA3Ae8DvmCM+aEQ4mvAxcA/d2+njTEHCCHeCFwFnP9fPYFWGqU7aDugaLlU/ALNuMorTziKZ9dtZEFxkNgogmI1778j8QoWxpI40sc2CssqkaYpAJnRDAU5sydVGbZXJjYCEyuKhRKe1jRrEwSBR6TaBIVKrsr1EuxUYxlNn+PRYyRlWaS1a5zWzl0UOiG9AiJH8fhTTzGwcjHb+jIm9VzkooUsXX4Izt33IdMWJhBYxiZMYiw0pVKJuNkiTVMcK2ecTExM4Pt+HpjuOPh+Pnw2QiDtnKtfrVaZOzhEsVhGqRQQxGl+0uh0OmRZRpKkeRupq+y1bIFAIGS3zQM5U8fkO/+nn36aA5Ydwp49e3jqqafyLIIso9JTYUF/H1apyIMP3cshh65gau8YtUaDNE1pNpu5OCyDwHWwywPUopBKxeEvP/pl9qYSbIEwiue2SSZqmqs//wHS6lx2T0xywqJVXPLu13OMnbLI7eGiD3+MDTsbaAyuyNgbxtiOnAnKKRaL+ZwjSTBGE8YRUZxg23mbTmJhO+R+RSpFKXAcD6VSBPlMpeQ6z884XoS1PYtZ7G/4g0Xf5PSPVvdLp/thgJOAN3Xv/y7wMfJ/jLO7nwP8GPiKEEKY/yKiq1Kp4tgBZQOJFWE54OBSqfTx7S99g1cdu4SFK44kNRm62wYxSiGkwVL57l7rDNf1CcMQz/UwRqHSDE+6JFmEEALbcWm2G+gkZbBcwU41fZ6D2baLzo5dmL2TvOcnP6T56IP84p//GWfZfMIFi9le0owtHqRRCxkbHafXLzBQ6WGp38/Kk45h6/Z19A0toeyVaGcxXskjbbdRwiCEQWcZYSvDQhAEAWEY0ul0CIKAJEkQXe59HMckXRqnEHkRj8IEYwSddpQbtEmLKIyxpCDThkzl3kFC69/Li913q3ReAA3dAa+CK6+8kiOPPpTh4WH6+vpwA/A8D5O22NWKkbUEbMkNN97GwgWDDA4OUmu0SbQiVhlFx0NaPqOtNme94WLqT62nufFnWLbLy485nFNPPxlf2jz4b5+lllWJpxSDPQsJggK2VSSsK667+QsMrD6N3oE+Qm0xREpv7xwMCcViIbdQ6HS6MwmF5/n4loXvBQiRzymwwLIctNYYI5ES4ixG6TxDGSRhFHWFai/O2p7FLPY3/FE9fSGEBTwCHAD8E7AJqBlj9oXC7gT2ediOADsAjDGZEKIO9AMT/5/HvBS4FMBzHKQ5EFEMsNIGOmwzb/kxtLwKf33Fu/jRP/4TC18eIhwbYQxJFGFZAqPBKHLOJzA+tjePTaxY4AjswMPDYW7mUwojCqPTxFs2YxqTKAFty7DLsek/fBV9JxwFbpFzLn0Hr3rzm8nOewN33nU3W2+4lV07d5KkKdKzKXsBDd9jbPdOjjzqCHp6+/izgy9g+8YnWdY3B2Ey0maG6+VMI9uReI5NFCV0woRmJ+pSUOOZwJdMKSzHyROvui0eYXL6qZSSVOXumpadD6cd16YTtvJi320H7csLRuhcmNWlgOb1KOdxKqUICj4Dg30csebYbtC5k199OA5YAlskSKdM2g6Z0xfg2j7btuxg8ZIlpHFGo9HAV4p2KFi1ZhXS6+GUU89mzUuPZnJqL1G7w66tuzhoZA6teoTtQGgp0qTG9JSNpw2Foouu9rNwwXyMADuFvTufYzRNqFZ8SpXcFtu18oB6afKgea9LbdXdcPk4jlAixXcDtDboTKONRhqB1gYcges4/6U46396bc9iFvsb/qiib4xRwGohRA/wU+Dg/+yw7u1/xo/7DzshY8w3gG8AFIsFk4qQNFR4yjDWbtB/oEcrnKA2uo1aG/aOTjK4YCin8iEougW0BEmGJywqtseBvQOk7ZDOtl3Yu8cx42MMFH1q9XEatqS4+jBG3nQWm7OEEAcjJD1As9NhOkmRSRttGbKwyXh9mkfXPkTB8Zg3NES73cYrBFiOTTS1HdsPuPSd7+G6b3+dvjRkwxNP8LVHH4EM7KBAHEY4roUlHcJUk2GjTIrs7vZN9+QVBAFRknQjDmMcy0KYnHcOCQbF4kXzePTRR1m9ejU1DAU/t2NodUIa9emcnrjPt0fl7p37Cn9+daDQ2iCwSBNFmigc28N28mGp5+XsHWGBZRzSLEE70MnATxMqlTLjE3vpHRjE9xzmLpxPu93BGEnBt2nU9pKECXMHRggWeJSKRTr1JmtWrWReTxEx2SSKLdKCIU1Tesr9nHP+hYyOT+PZRVI62EiGRwbJMk2iJIVKmamJCeiEFKolTJwStdsoIegv9zIZNbCQWHYu7Ms0XZuIPB/B9/3cd4d9J74XZ23PZuTOYn/Df4u9Y4ypCSHuBF4G9Agh7O6OaD6wzzN4J7AA2CmEsIEqMPUHHhm9bQe2nMb2fOYMlykNDHLmS1bz+U//iov/7t1s3zzGnP5+wjDEDmOGJhvEu0axWiG+lbd3OjqmbRvsuXNRq5ei3EPYkqTUVUpQLjGtNdHOURzfQeftf4Ig9+LxPQ+NwvFcpqeneeqpJykGPrbtIgwUi8V8OKg0jjdAhuFLH3k/x7zsOH7z7EZKc+fxvr+5nPe/493ESUYGqAyk1Ahh5cNIkesD6vV6voMFOp1OHujdbs/s2guFAvVmc2aguW3rduaPLKA2XadYKTM2uptjjz2WrTu250IvlWCMmSny+z7f58m/7zZLVXd4nF8F7OOva61nmEQzqWFZNnOlkQvGMqampigFBVQaYgnNxo3PcPc9d5OmMUcd9VJe97rz6OvvJewk3PXAIzx651OM7f00Mm4x2mryyhPOYKSQMKesaYY2YRsSu4MjNKQpsZG4UhA2aujQQytBoVwgDuPcNwjJ9Pg4cdRmoH+EVCVkWYI0Cp0pLFcSxSmOIwnDBETubaT/iO7L/9zansUs9i/8MeydQSDt/lMEwCnkA6w7gPPIWQ5vA37e/ZFfdL++r/v93/yhnqdKU45dkjDP07STDmP1mKs/cDWRDTqDr608kTXVfuQzWwmzjKbvMF4swtJFtK2EUGiwfNDgYKMFSFLQGW5QwlIx7XY7NzpLDVIwUxhDE+G6LlGc0I461FpNfvaz6/PZgW2ToXC6TBspoOIXaBQdfGVTXbCCGx64h9WrDyfLNK1Wh9iSgE0YRXkwTJxgObm1bzsMZ1oqlmUhuq8hjmNsN6eWWpaFEVCv1wmCgCzVOH6AXyx0TwIZld4+nnjiCRw/p2fu4/jve5u11jNtm32K3DTJrSBe2A7SOi/6UkoEeZ9cKYVtuUQ6Icv0zGNkWcaqVat45qn1M4rX5csP5KKLL8XknqE0m22SZBeNVsjatWt5OpGsX7ubT33kco6YN59w53amd9/ED352M1lHMj3eYWe4i8P6+jj/1S+lsmAe69Y/gyg7FNyAtJ6SpilDg8N0mg3qcZN5vQNoYdOsT5Iajev62NKh1WoyPj7O8PAQ0uRtryAIENpgWf95e+dPsbZnMYv9DX/MTn8e8N1u71MC1xljfiWEWA/8UAjxSWAt8O3u8d8GrhFCPEe+C3rjH3wRrsdXbpngijN60HbARKfFua89jA33PcLwoqU4Cyw2tAMmowY333g7rz77tdhuPvxMQotSUMYYRZImGDu/tYzAdV3CqIERNtLO83KDgk+qFLa0KBQKOf0zzemBlmWBFLRaLcrFIgCWtFHKkGUapQ3N9jSB7YJr0WxNobXhlltu4+TTTuX6719LGsUIIQiVwsrUTFF+PgkrL/Ku61Lw/Znd/D6XzTiOMenzxXvffVLSPVnkxVx2mTr76JovTN8CZoa6L4Qxppsalr8uIXI2j225mG6XYt/j7PtelMQEliTLMvbs2ZOfmIQkTuNc/+B4M8+PUQgsHn7oCdY//Sz9QxWGB/spVvto1hp4/XO49Iq/Ye0tt3P0QQey6fZbedunPs0v77iL917xVQ5aMhfXjdm2ZZpzzjmek199DlsnW+zeu4XMFqSpRa3ewPE0fhBg2xZGp2RK0ddbIAiGCcOQarWX0dFRtm/dxsDQYN7ff5HW9ixmsb/hj2HvPAEc/p/cvxk46j+5PwJe/999IR3b5pnJAp6awHMKdMI2xh9g3WNP89i2jZz+ukvwA4dz3vgGHn14LUuWLMUNfKSE6bAxozxVYT6U1NLQSeIu0yOhUMgtjVWmyDKB5VvUW+3cqthyyJSe4cVLK+8Pp5kG6/mCGscxru/RzkKUJRlZsphVRxxBY7rBnXffSXWgFxNYWLFhsFChkUYYpXLLY20QRiGEpFKpEIYhSZKQpil+oTATpFLwfbIso2FyuwZhcstkz3NpNluMjCzIh7lSoEXOuml3OjMFf18Yy77iv6/Nsy+0Jc2ymSKdm7FZ3c8FoJ4XjHXfC9vuzU3eHI96vU6xWCSKOjiOTaVayHUJWYrrOWBSjDY8+NDv0CZjfKyJazSdJMYRYJRkxQHLefr+B3AOPZz208/wy099ggVvfwtDcy9k0crlDPX08fN//Ty33HoXY9vW8+YLL+PlR8znt7f+lpsffIJFx5xEuTTChi3PMtDTz7rHH2BosEipXKSvfwRjW+wa28PE1CSLFi0iyzLiJH5R1/YsZrE/Yb9Q5BrynemKMy+i3ZlGKUMh7jD/kAKOE9BT7aVWqxGUCjiuYOUhB2FSSMOUTOZDzCAo0u72xfMiBsYIbNvCkc+3NCzLouDbaK0o+h5aZbi2jRGSOMsouA6JGyAdB9+zMDZkcUJQLBJEXpcdVMV2fJYuXsZ3v/td+nrKDM+ZS19/LzfffAuJFjiuRqagRT5ULRQKdDoRqVK0220AlJT4hQKqK8ZKkgQlQBmNgK41hEXB87Esm2KxSLvdRAhBYsTMbvyFu3rbtnOmi+f9nrWDUgqDohCUCDu5GtmyXLp6LrIs+T1xlxACKSVxmuEIg3R9xiemyIwmcG1Ul/Mftafw/QKJ8ohji1Zc4+qrPsfbL74ErRIufcclmMSgHUE7S1j/7C42t9tM3f472oUS8UGrONS3OO24g1h732Pc+/OHeeh3G1k+p8KD6zps+fIPaU9sYkHVZndkE+zZTaF3DoesWI6xJKfNP51ms8no6B627x6jUCiw7IAlvOH88yiXy0gpuf6nP/tTL+lZzGK/xf5R9LXBGIvf3vMgRx39Uv7lW99Capfly5cxMjyEH+whCFxU0ibOUjJluO3Wuzj11FPzQWaWEcchUkKaJiRJzoqxbQtjFI7v5z48rjuzA96XLqW1nmmv5L1wLw8W8WwwkjiOsYREpRkGhdags4jUGG6+8QZQGUmUMD25ld2jO7qOlLkhWOC5M60dozJAo7XG67ZyhGURRdGMxbKUMnewVJqh/oH8dWpNZjR+dxawb9C6j7ETx/FMkX6hmnefR/++fnxub+CTpintdnvme/sGvfsK/kyrhvxkIbRBuDae5+W+RYWAtNVECcUj99xJ/Zm11HZs5fDVyznprLO5+eHHeejWGzlm1UKSeotnHriLVxy9muUVi+1Pr2Pzpo2U0ioqa5DEbQrVIX51w4386gfjDC9ZyppX/hnvOft8tm7fxuiuMSwCzrvsfZx97quxpGR0dBebN21jutkiC1sIS7LsgBUcdHCuxZAWxFHKzh2jlMtlyuUqtr1fLPNZzGK/wH7x3yAEWDLjjttvZd3jjyMtG21q7N3zHOUAeiuLKPkewmhKgU9m+D/tnXmQHFd5wH+v7zn30p5aXWtbsmXwIWTLwrbAF2BiTBJsMCYVQ3CSgkoqGFIUrqRCpThtSKBSgSKuhAqHAUMgYEw4HHMEbGOQkeVTsiUsIe+h1e7OsXP0/fLH655dKU4qPrS7xfavamp6emb7m5l98733vpMrr3w1MzNzrFnTi6np6LqGaRoIAWEYdZRaasYAOqn9aR/XxbbtZrOJF/pJVqvEbzZVHH2UmHfiGKHrtF2XPDnV2SqOyOV0oqDFwJpeGu0WtuPQaoY4dp4o8Du1glLiOEYzDCWz3cYwDCzHUaUYQhVdY1uWcgSbJq7nHvf3hmFgajqapmHl8hjGROe6qfJOG6ynaDog6UxAprXw3YA6n5aFEEJ0TEFhYgryfZ+evgHGJyYY6O3ByZt4eoGx9Wdw5umbuPPfv8HX732KxuztuKZBb+UIA/3rmZqYwpyaYt/PDvKwX2a86vL0sWl61g1wdHKc3p4iv/fa13DO2VvYsOkUXL/NxDPTzE4fo6d3A+dt1yjbDlapzBOP7SNXUJPW+vXrGW67nd696WSY9ipQE6JQ2c1SkLlaMzIWWBFK3/cDThvbhK3rDA3209tbZmhkHdMTE+Rsm9D3mJtzMQwLP/SYq1XJ5WwajRatZp0NmzYqh6RhkM/ncV2PgwcPsmXLFgzDoN1uq0iYZEVtCA10OvHybhIvb8Qms7Oz5PN5Jo8exUkcrUEQ4HnKP6Bs+2oVbRga+byDrmuEfkyYmm6kRegHhKEys7iu29lVpOGQaSgkKNt5zrbRDF3VEZIxtm2jJzuCcqFIs9VSyi2WOMViZ2UOqgkNLNjp011L6ovQNXGcku/04E1IX5e+xk973Hqeaudo24yuW0d9fh7D1LEMGzwPPdSpzLQ5//xdBG2f0S1r+fSnP8v5XfDYg7/hvAu3ceWb/4Qrr/ldPK/J0fEp9j89TuB6+CEUyzqlUhfStjk6M0MYBDiFPBtPXUcY6+jCIPY93DjGlBEi0tGFTr3RJJ/PU69WVCaxlDhOnjhWE7t6/3qnXHVGRsYCK0LpO46DpgtKeVs1+fADpiYO4s43aVYk68dOwbAdQqmRKzgMjgwyMTFBbW6cUjGpU2+pHUAYqmSjzZs3d8IydURn1WoYBmEQqhoyrp+sbBfMIevWreOpp55C0ww8L8CLQoSUzM7OUi6X6S53c8llF7N582bGn3mG9es2Mjs7S6FcxpOq/LBjmsjYxwti/DAgkjEy6YcrdBMJScjkQietdKUudJ1ISsIgwECiCY3JyUl6enpU+KRQdnq33SaYb3Z2K4vt+mlnruMarQuDOOa4kgSpSaiTxNXxh8jO/wVUNuzg4DAzMzPUKzPMVWaoe21OPftMLr3yUraecRbFfJnDx6Y5/ewdRFHEmr5hdF2jUWvys5/eR7FYBBGztn+YmWoFy1b+ipxtUyj0MTc3ja6pommRbqKhM9+s0N1Xwgp0ggDlvA488k6OKAgpl8vJziZS361UPdLS0gxxHJLPOzxL/lRGxqplRSh9XdfQDIP1YxtpVSsYhsGa3n5aRY8IScMPePrAASzdoqevj3y+SC5fZtvOnVRnZ7j3vp9wySteg65JIhnjhRJDCHzXxTQsYj0GdExNx48ChKEDMbqZJwgC5ioz9Hb10mq5vOrqqzh022285x3v4tPvv5mLrnkj9WaVdrXO1PfuwT7rLIr5bg4dfDKxjecwdA3PddFiMDWTUIbEsYYwdDShqVpBSQRNjLK7G4mJR31+HS8phRBHEaauq3DTpFPV0ekpZBzR09PDwacPcqxcpLu7m1iqcM84VrsctapNMnBlmETmJLWJpIYQEZpmkHNKgHLYGrpOIa+Ue7U2S61WY6B/iDO3bmHPnt04jsPk5CRTRye47NKL6erqYq5aSXYsPkMjIxyZnMBxatTrdXr7htRuRxMEUUSxp0R3Vy9OzqLd8jAMg7UFp9MTWIWqhnR3dxOGalJOJ6tcQbWFdByNXC6nTF927rjJKYrkcQ5ojYXvVEpJo2m31dIAAA+JSURBVNHi2RNpMzJWJytC6cdhwCkDZeJmlZwF8+0K80ebrB1ZR9T2KRUKbD/7XDBMXNelXqmzcfOpzNbm6Onp48KXX4wXtsk5RWwL2l6STWoYBFIj7xTI2xaDQ6NUKjWmxw+hF4sEfgM/aV/4b9+8g507d/DtO3czMjLKt+76JqedMspcdZ5f7r6XWrPONlvDcnJ4QZupiWm6ervQjZg4gkq1qiKEBGhCkMs5+IGAKO6UTU7t+anZITWrAElPAPVevMT3YBgGzXaLweERLN3g0OHfkC8UqVTnqVTnyRXzytFs6Mg4ragZoKHMQpIIIWIsy8S21SRy+PCvabt1evtMduzYwdiGjUxOHmVqaoq5Wouurq7E7CV4+vAhisUSzWaTWAo2jo0RRRHFcpmcU+iYkByngGmalIpdx5mtYhkShWqVHQZqN1GpVLAsi1KpC8tykHIh61fKqBM1lO5gUuWdmsZOzDQGOruVxcXmTjRhZWRkKFaE0jcMHd0QShkiWNM/TG12in2PP8GZZ52DlJKfP/gA27Ztx7R0hkcGmZmZAR2K+QIt1+N73/0O115zPV7Ypua16M+VqXhNvvy5L7Bh/ZlocRtfC9i/72kuu+RCXnr2SwjaTYpdZbadu53Pfu42fvDDGhfvOp///I/7GRgpsv3cC3jq6cdpBVX6hntZu2OMllHirX90I5/42McplvrwAokIY2IBbuAzMDCglJIwcD0TGSpbeT0pT2wIXbVJhE51TV0IpKbRbDbxfb/jf4jjmEKhwN69exkeHmZoaIh8vkhXb1/iY5BIWaftLkTqIC1VsiBqoxuCq193Fb1dg4yPjzM1NcXOHRfwpmvfhNAFhlGm3pT4kUlP33r6B1UiWprRq8xBAaZh079mUMXyayG6HhHFarcShZJmo43jiI6JKHWSG7pF4HudnY5pGnR39x6XSBaGPnEM+Xx+ocvXoolDhZbqHUUOdF632BGdHqcJcIvNVNk6PyNjAbESssh7uory2t95JZqmUZtvIjSTYs6gq28A1/NxHIdYQByE5PN5ZqZnyRWK6KaJpoNj5/ECl717HuaCnbuwNEEz9CCSFGfn2P+lr/H7H/gIv5w8TMubof7TJxi75tXEcUxXTw+lUhld1/jVfbspDhb4yIf+jrHT+jEMg/Mv2I6nSeamjzF1rMrZY2chY42hNf1Ydo5YE1iaTstrUanU+M3hZ5BJ5IsXBMgkqSsMQ44cOQKahqnrqoaQZSEFBJ5S9Km5wzRN2u02URTRdtt84uO30NXVA7pGsz5PIZdH06HRaLD/qf0cPXaM4eFhwshnZHSQ11/9BnK5IgKd+nyVxx97mCce388VV7yK3p4BpBS4XgNNT0JHhTKRhFGSLOaoKBld1zENO/kvKSWsGrOIzmNNGEgCpIw6CjuKIubmVBMbKdOyEwuTQhjG/8P/AAvRRZ6nkqnK5XLHEZuu/Bcr9HTsLr5/tuduuOEG9u3btyy6Pyu4lnGykSqz8v/Niljp67pOuVjCD1zWDQ8RhlDsLbN/3wG2bn0Juq5CKtuRj+u6dHV1QRK2KITa6huGxdYzT+e/fvwTXnbeNoqlHAJBpU+nbMK3P/ABtt305zypRUz2m2xfs0YpylB2GpKftWM7tVqNbeeew9MThyjlYGZqlpoMcTSN5rEGha02ppkjXyjQ19fHEweexGu7ifIyGT9yRK26Y0EQB2lojVqt6npnFZt2hIpkTHe3KiXsBy7tVpN8MQ8xOJaF67o4jioXEfkulqnju61ORJIu4JRNG5ipzHDTTTcRBDqaSCaNUGIaNue97CLOOfs85dgs6Hz4wx9k44YtvGLXJfT09Cz4AjCxTBMZC2zLIgiCjrJttxuUy91IGSFlgJYkxanchYUCbulKf3BwsLMCr9fri0w4ytGu62bHlLPYt6EicZSPoZ2EtKZ19VO7fiorVe7priA1mZ1YfiIjI2OBFaH0pZRU6zXiKKDt+vT0DRL6AWtHR6hUZlUMtmmom2PTarYxdFUmOJQahuWQyxUIYzh16xiVuVkcZy1e1MYQBbRtW6nft4e7b7mVy//6Zuobt9DX3UsYqlK/hmnTaLa56d1/BnEO16/yxmv/gAd/9TM0w2T64BHCOKJWnaftxVSrR9m9ezflUhenn7GFNcNDRGGM6zVVPfwQDDNGQyASJy1J6KdlWbRcF9sxue6667j++uu5/74HuONrX2Hr1q2MjY1hmia33HILmqb+PYODw8wem+PIrw9z//33EvguhmFwxRWXsXZolE2bN7BxbDO1qovQDHw/TCZCQzVgcdvKdBZJms2Am979Xgxd0Nc7wEc/eisjIyNcdtkl5HIlPK+JlDFRpHWcqnGsFLNSvibNZoOuri50PTFVaRrpYiOOQdP0pN6NhpRQKJQgKcrm+z5zc3P09PQkSt0in88fVx56cXYxqCiiMAyPK/6WThaL6xot9gUsHlsZGRkLrAiln/7IBTrFYpFWq4Wds2i12uTsHKVikXa7TYyqLbOmv4/KrHIIIpVz0Mn7hHFMa76F67bQTYNcqch3fnAPfhigb9lMHEqe+eZ32XXxhdRbbWrVSQxhJEpZ8q6/fC8ffP+HkFJy++23s+nUYQ4feoaZqVncIMRr+bhek2Le4pWvuBDPDbCcHDImKc9coKu7kNjCLXyvqXrgJk7axWUTtr/sQi695HIe3L2H8fFxhgdH+dIX71DtHQ2DYj4HgGVo7H/kIb7x9TuwHZNyuYyMQjQR4wYNvnrnt/nHT/0zs3M1NM0ijptYltVRioZhYNtpCGOM4zgIJLruMD4xzdtvvBFJRH//Gj7xyVt42bm7OO20LQiRmmt0kAa2XUDKACEkxWKZVktNPI1GA9u2KZUKuK6LnpiMFq/C097FQeBh23bn+wCoVudUk3lA04xkF7DgsFXntU7y2IlJZa7rdq652Lyz+D4jI2OBFaH0kRJiSalUUvVcvADLUPVqdNumFUUEQtDbswa37XN0pkY+X8QLfGzHpun5NFptQt9jenqa0ZFRRBSSt2za7TYyVoq24TbpKRWpzIyzf5+rCp61PeycTdNrcffd94OIsHQTPwxwXZ/5SoNaVbXgQ8LE+BRbt76URlutPN0wIopihvoHWLthhPVPriOIIg4dOoSdyzHYP9Bx4o5PHCGXRLrce++93HfffSpix9IR6JRKBaIorXsDlVqVnGOwe88DbNi8Ec3QGR1dx+bTTqfU3UWj0eDWj32Kw7+ZxDRthFbBsQsqokfXO43F2+0mlrVQ0dO2ber1eifzVtd1jk1Xecub/hhETKnk8Mije/naV7/JW9/2NkZH19NotDpF2aQUncYr5XIZKWVSulqj0VDF79TEs3B9VQhOlZg2jDSE1aJQKHQKxWmaxvj4Ebq7ezvOW9M0O+Go6QSSTqCapnV2CWnnMD9pSLPQ9D1b6WdkLGZFKH0pJc3WPI1Wk+7eNYRxRGWuTq5YQLoBTr6ILgwmxqfI54sI3WDy2CwTU5P09vaqH3cUYxk6k5PjrB0ewiDHI3sfQtNj5mstDCfHpo2nEjWb5HNlms0mpUIBKaE2P0+rUeWKy7fT3Xsxs9MR//q5L1Aq5Dk4PqvaMUpV0dKybH796wNs23YuZ5+7k3q9jhAamrDw/Cavu/oNzNfq7Nn7cz7/+a9y0UW7OHZsVkXEaGZH0aYmCE0z8Fwf11etWlMnqbKHwxlnvpRdl78ay84nTlEbISSVSovR0Q00Wy5f/PzXecc7b6TRaNNuz1Iq9nQUnuu2sO0cnlfr1PGfn691FKNaQavELSFULsGxmRrDwxu46T3voru7m3e+80+56qrXc/55L8dKbP0nNmpJlbBlWYCGEDrV6hy2netkPi+u+5+uwH0/zZhVDt6hoRGi2COOYqamjlIulzFNu+PsTTNwU9kn2vXTbGQpZSfhLsvNyshYYEVE7wgh5oH9yyR+DSf0OP0tl7ucspdL7gYpZf8yyF3OsZ2Nr9Uh+zmP7RWx0gf2Sym3L4dgIcTu5ZC9XHKXU/ZyfuZlZFnGdja+Vo/s50qWspiRkZGxisiUfkZGRsYqYqUo/dtWoezsM68OVuN3nX3mFcyKcORmZGRkZCwNK2Wln5GRkZGxBGRKPyMjI2MVsexKXwjxGiHEfiHEASHE+17ka39WCDEthHh00bleIcTdQoinkvue5LwQQvxD8j4eFkJsewFy1wkhfiSEeEII8ZgQ4i+WULYjhPiFEGJvIvtvk/ObhBAPJLLvEEJYyXk7eXwgeX7j85WdXE8XQuwRQty1lHJXGidzXCfXz8Z2NrafH4uzGpf6BujAQWAMsIC9wNYX8fq7gG3Ao4vO3Qq8Lzl+H3BLcvxa4Luo8usXAA+8ALnDwLbkuAQ8CWxdItkCKCbHJvBAcs2vAtcl5z8DvCM5fifwmeT4OuCOF/idvxv4EnBX8nhJ5K6k28ke19nYzsb2C/ocyyocdgLfX/T4ZuDmF1nGxhN+GPuB4eR4GJU8A/BPwJuf7XUvwnv4FnDFUssG8sCvgB2obEHjxO8d+D6wMzk2kteJ5ylvFLgHuBS4K/mRnnS5K+22FOM6uW42trOx/Zxvy23eWQscWfT4meTcyWRQSjkJkNwPnMz3kmztzkWtSpZEdrINfQiYBu5GrTqrUsq00M3i63dkJ8/XgL7nKfqTwHtJ6yir6yyF3JXGcoxryMb2idfPxvazsNxK/9nq3i5XDOmL/l6EEEXg68C7pJT1pZItpYyklOegVifnA2f8H9d/UWQLIa4CpqWUDy4+fbLlrlBW2mfLxvYLkP3bNraXW+k/A6xb9HgUmDjJMo8KIYYBkvvpk/FehBAm6kdxu5TyG0spO0VKWQV+jLJ7dgsh0lpLi6/fkZ083wXMPQ9xFwJXCyEOAV9BbYM/uQRyVyLLMa4hG9snXj8b28/Cciv9XwKnJV5wC+X0uPMky7wTuCE5vgFlk0zP/2ESbXABUEu3q88VIYQA/gV4Qkr590ssu18I0Z0c54DLgSeAHwHX/C+y0/d0DfBDmRgjnwtSypullKNSyo2o/+MPpZRvOdlyVyjLMa4hG9vPJjsb2yey3E4FlHf/SZRt7q9e5Gt/GZgEAtTs+3aUbe0e4Knkvjd5rQA+lbyPR4DtL0DuRajt3MPAQ8nttUsk+yxgTyL7UeBvkvNjwC+AA8DXADs57ySPDyTPj70I3/srWYhwWDK5K+l2Msd1Nrazsf1CblkZhoyMjIxVxHKbdzIyMjIylpBM6WdkZGSsIjKln5GRkbGKyJR+RkZGxioiU/oZGRkZq4hM6WdkZGSsIjKln5GRkbGK+G/Ii2swbmaHVwAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'P' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-9-c209bdef6b4c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgt_colour\u001b[0m \u001b[1;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmdl\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlabel2rgb_colors\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mgt_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mgt_curr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mgt_colour\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m&\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mgt_curr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mgt_colour\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m&\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mgt_curr\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mgt_colour\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m     \u001b[0mpred_mask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mP\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m==\u001b[0m \u001b[0mk\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m     \u001b[0mY_raw\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpred_mask\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m*\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mexpand_dims\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgt_colour\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0mY\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mgt_curr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mgt_curr\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
+      "\u001b[1;31mNameError\u001b[0m: name 'P' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    gt_mask = (gt_curr[:, :, 0] == gt_colour[0]) & (gt_curr[:, :, 1] == gt_colour[1]) & (gt_curr[:, :, 2] == gt_colour[2])\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    gt_mask = (gt_curr[:, :, 0] == gt_colour[0]) & (gt_curr[:, :, 1] == gt_colour[1]) & (gt_curr[:, :, 2] == gt_colour[2])\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/.ipynb_checkpoints/03_sec-voc2012-checkpoint.ipynb b/03_sec-dsrg/.ipynb_checkpoints/03_sec-voc2012-checkpoint.ipynb
new file mode 100644
index 0000000..c84f78b
--- /dev/null
+++ b/03_sec-dsrg/.ipynb_checkpoints/03_sec-voc2012-checkpoint.ipynb
@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-voc2012"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 10582, 'val': 1449}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'VOC2012'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, '--seed', seed_type, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    G += np.expand_dims(gt_curr[:, :, 0] == k, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth segmentation')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/03_sec-adp-func.ipynb b/03_sec-dsrg/03_sec-adp-func.ipynb
new file mode 100644
index 0000000..bcc5b85
--- /dev/null
+++ b/03_sec-dsrg/03_sec-adp-func.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-adp-func"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 14134, 'segtest': 50}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'ADP-func'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, \n",
+    "                             '--seed', seed_type, '--setname', setname, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\ADP-func_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\ADP-func_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Functional\\n ground truth')"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(gt_curr.astype('uint8'))\n",
+    "plt.title('Functional\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/03_sec-adp-morph.ipynb b/03_sec-dsrg/03_sec-adp-morph.ipynb
new file mode 100644
index 0000000..bad6b4c
--- /dev/null
+++ b/03_sec-dsrg/03_sec-adp-morph.ipynb
@@ -0,0 +1,381 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-adp-morph"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 14134, 'segtest': 50}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'ADP-morph'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, \n",
+    "                             '--seed', seed_type, '--setname', setname, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\ADP-morph_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\ADP-morph_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Morphological\\n ground truth')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(gt_curr.astype('uint8'))\n",
+    "plt.title('Morphological\\n ground truth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/03_sec-deepglobe.ipynb b/03_sec-dsrg/03_sec-deepglobe.ipynb
new file mode 100644
index 0000000..0206050
--- /dev/null
+++ b/03_sec-dsrg/03_sec-deepglobe.ipynb
@@ -0,0 +1,392 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-deepglobe"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 603, 'test': 200}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'DeepGlobe_train75'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, '--seed', seed_type, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\DeepGlobe_train75_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\DeepGlobe_train75_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    gt_mask = (gt_curr[:, :, 0] == gt_colour[0]) & (gt_curr[:, :, 1] == gt_colour[1]) & (gt_curr[:, :, 2] == gt_colour[2])\n",
+    "    G += np.expand_dims(gt_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth segmentation')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/03_sec-voc2012.ipynb b/03_sec-dsrg/03_sec-voc2012.ipynb
new file mode 100644
index 0000000..c84f78b
--- /dev/null
+++ b/03_sec-dsrg/03_sec-voc2012.ipynb
@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 03_sec-voc2012"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import time\n",
+    "import pickle\n",
+    "import cv2\n",
+    "import numpy.matlib\n",
+    "import tensorflow as tf\n",
+    "import skimage.color as imgco\n",
+    "import skimage.io as imgio\n",
+    "import multiprocessing\n",
+    "import pandas as pd\n",
+    "import traceback\n",
+    "\n",
+    "from utilities import *\n",
+    "from lib.crf import crf_inference\n",
+    "\n",
+    "from DSRG import DSRG\n",
+    "from SEC import SEC\n",
+    "\n",
+    "import argparse\n",
+    "from model import Model\n",
+    "\n",
+    "MODEL_WSSS_ROOT = '../database/models_wsss'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "len:{'train': 10582, 'val': 1449}\n"
+     ]
+    }
+   ],
+   "source": [
+    "method = 'SEC'\n",
+    "dataset = 'VOC2012'\n",
+    "phase = 'predict'\n",
+    "seed_type = 'VGG16'\n",
+    "if dataset in ['ADP-morph', 'ADP-func']:\n",
+    "    setname = 'segtest'\n",
+    "    sess_id = dataset + '_' + setname + '_' + seed_type\n",
+    "else:\n",
+    "    sess_id = dataset + '_' + seed_type\n",
+    "h, w = (321, 321)\n",
+    "seed_size = 41\n",
+    "batch_size = 16\n",
+    "should_saveimg = False\n",
+    "verbose = True\n",
+    "\n",
+    "parser = argparse.ArgumentParser()\n",
+    "parser.add_argument('-m', '--method', help='The WSSS method to be used (either SEC or DSRG)', type=str)\n",
+    "parser.add_argument('-d', '--dataset', help='The dataset to run on (either ADP-morph, ADP-func, VOC2012, '\n",
+    "                                            'DeepGlobe_train75, or DeepGlobe_train37.5)', type=str)\n",
+    "parser.add_argument('-n', '--setname', help='The name of the segmentation validation set in the ADP dataset, if '\n",
+    "                                            'applicable (either tuning or segtest)', type=str)\n",
+    "parser.add_argument('-s', '--seed', help='The type of classification network to use for seeding (either VGG16, X1.7 for '\n",
+    "                                         'ADP-morph or ADP-func, or M7 for all other datasets)', type=str)\n",
+    "parser.add_argument('-b', '--batchsize', help='The batch size', default=16, type=int)\n",
+    "parser.add_argument('-i', '--saveimg', help='Toggle whether to save output segmentation as images', action='store_true')\n",
+    "parser.add_argument('-v', '--verbose', help='Toggle verbosity of debug messages', action='store_true')\n",
+    "args = parser.parse_args(['--method', method, '--dataset', dataset, '--seed', seed_type, '-v'])\n",
+    "mdl = Model(args)\n",
+    "mdl.load()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Build model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\ops\\control_flow_ops.py:423: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Colocations handled automatically by placer.\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\model.py:308: calling squeeze (from tensorflow.python.ops.array_ops) with squeeze_dims is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use the `axis` argument instead\n",
+      "\n",
+      "WARNING: The TensorFlow contrib module will not be included in TensorFlow 2.0.\n",
+      "For more information, please see:\n",
+      "  * https://github.com/tensorflow/community/blob/master/rfcs/20180907-contrib-sunset.md\n",
+      "  * https://github.com/tensorflow/addons\n",
+      "If you depend on functionality not listed there, please file an issue.\n",
+      "\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Documents\\Grad Research\\wsss-analysis\\03_sec-dsrg\\SEC.py:283: py_func (from tensorflow.python.ops.script_ops) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "tf.py_func is deprecated in TF V2. Instead, use\n",
+      "    tf.py_function, which takes a python function which manipulates tf eager\n",
+      "    tensors instead of numpy arrays. It's easy to convert a tf eager tensor to\n",
+      "    an ndarray (just call tensor.numpy()) but having access to eager tensors\n",
+      "    means `tf.py_function`s can use accelerators such as GPUs as well as\n",
+      "    being differentiable using a gradient tape.\n",
+      "    \n"
+     ]
+    }
+   ],
+   "source": [
+    "mdl.sess = tf.Session()\n",
+    "data_x = {}\n",
+    "data_label = {}\n",
+    "id_of_image = {}\n",
+    "iterator = {}\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    data_x[val_category], data_label[val_category], id_of_image[val_category], \\\n",
+    "    iterator[val_category] = mdl.next_batch(category=val_category, max_epochs=1)\n",
+    "first_cat = mdl.run_categories[1]\n",
+    "mdl.model.build(net_input=data_x[first_cat], net_label=data_label[first_cat], net_id=id_of_image[first_cat],\n",
+    "                 phase=first_cat)\n",
+    "\n",
+    "mdl.sess.run(tf.global_variables_initializer())\n",
+    "mdl.sess.run(tf.local_variables_initializer())\n",
+    "for val_category in mdl.run_categories[1:]:\n",
+    "    mdl.sess.run(iterator[val_category].initializer)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Load model from file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading model from previous checkpoint ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n",
+      "WARNING:tensorflow:From C:\\Users\\chanlynd\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\training\\saver.py:1266: checkpoint_exists (from tensorflow.python.training.checkpoint_management) is deprecated and will be removed in a future version.\n",
+      "Instructions for updating:\n",
+      "Use standard file APIs to check for files with this prefix.\n",
+      "INFO:tensorflow:Restoring parameters from ../database/models_wsss\\SEC\\VOC2012_VGG16\\final-0\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Resume training from latest checkpoint if it exists\n",
+    "saver = tf.train.Saver(max_to_keep=1, var_list=mdl.model.trainable_list)\n",
+    "latest_ckpt = mdl.get_latest_checkpoint()\n",
+    "if latest_ckpt is not None:\n",
+    "    if verbose:\n",
+    "        print('Loading model from previous checkpoint %s' % latest_ckpt)\n",
+    "    mdl.restore_from_model(saver, latest_ckpt)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Predict segmentation on a single batch"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "val_category = mdl.run_categories[1]\n",
+    "layer = mdl.model.net['rescale_output']\n",
+    "input = mdl.model.net['input']\n",
+    "dropout = mdl.model.net['drop_prob']\n",
+    "img,id_,gt_ = mdl.sess.run([data_x[val_category], id_of_image[val_category], data_label[val_category],])\n",
+    "# Generate predicted segmentation in current batch\n",
+    "output_scale = mdl.sess.run(layer,feed_dict={input:img, dropout:0.0})\n",
+    "img_ids = list(id_)\n",
+    "gt_ = gt_[:, :, :, :3]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "j = 0\n",
+    "\n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    \n",
+    "# Read original image\n",
+    "img_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'JPEGImages',\n",
+    "                        id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)\n",
+    "# Read GT segmentation\n",
+    "if dataset == 'VOC2012' or 'DeepGlobe' in dataset:\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug',\n",
+    "                                  id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-morph':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-morph',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "elif dataset == 'ADP-func':\n",
+    "    gt_curr = cv2.cvtColor(cv2.imread(os.path.join(mdl.dataset_dir, 'SegmentationClassAug', 'ADP-func',\n",
+    "                                      id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)\n",
+    "# Read predicted segmentation\n",
+    "if 'DeepGlobe' not in dataset:\n",
+    "    pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(img_curr, mdl.model.crf_config_test, mdl.num_classes, pred_curr,\n",
+    "                              use_log=True)\n",
+    "else:\n",
+    "    # Apply dCRF\n",
+    "    pred_curr = crf_inference(np.uint8(img[j]), mdl.model.crf_config_test, mdl.num_classes,\n",
+    "                              output_scale[j], use_log=True)\n",
+    "    pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "G = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    G += np.expand_dims(gt_curr[:, :, 0] == k, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Ground truth segmentation')"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(img_curr.astype('uint8'))\n",
+    "plt.title('Original image')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(G.astype('uint8'))\n",
+    "plt.title('Ground truth segmentation')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Y_raw = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P_raw = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P_raw, axis=-1) == k\n",
+    "    Y_raw += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)\n",
+    "Y = np.zeros((gt_curr.shape[0], gt_curr.shape[1], 3))\n",
+    "P = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))\n",
+    "for k, gt_colour in enumerate(mdl.label2rgb_colors):\n",
+    "    pred_mask = np.argmax(P, axis=-1) == k\n",
+    "    Y += np.expand_dims(pred_mask, axis=2) * np.expand_dims(np.expand_dims(gt_colour, axis=0), axis=0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Post-CRF Prediction')"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAACeCAYAAADJ/EoAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAXOklEQVR4nO3dffQkVX3n8fdHcEACy8iTDjMjIzAmkl2DHJaHY3RZH84imtXNkgSSXYFF0RhCcnQTcc3G60Yiuh4RFyOQAwGyCIzRjSwnroeAoGwEJIIGwk4YFJhxBpDA8CCiAb77R90fU/R0dVf3r6of6vd5ndOnq+69db+3+3fr2/XQPaOIwMzMuuUF0x6AmZk1z8ndzKyDnNzNzDrIyd3MrIOc3M3MOsjJ3cysg5zcO0rSRZI+mpdfK2n9mP2cK+m/Njs6s8mTFJIOzMtjz2tJT0jav9nRNc/JHZB0j6Qf5z/a/Tkx7tpyzBMlPZNjPibpNklvbSNWRHwjIn625phu6Nn2PRHxR22My+rrmaMPSPqzxcxRSWtysttxSDtJOk3S7ZJ+JGmTpC9I+he5/iJJP83jeljS1ZJ+rrR9eZ4vPM6piHWdpKdym4ckfUnSinFf4yB153Ue0zt7tt01Ir7Xxria5OS+zS9FxK7AwcCrgQ9OIOY3c8zlwAXAOkl79DYatgPakrEwRw8B/iXwBxOIeTbwO8BpwB7AK4C/BN5SavOJPK6VwA8o5nLZN3NCXHicOiDeqbmvV1DsF2f1ayRph7FezRLi5N4jIu4HvkqR5AGQ9BZJt+Yj7I2SUqnuYknvz8sr89HQe/P6gfloRkNiPgtcCLwI2F/SUfkI6QOS7gf+LPf31nyEv1XS30h6VWkcr5b0bUmPS7oC2LlUd5SkTaX11fmo6IeS/lHSOZJeCZwLHJmPnLbmts9d3snr75K0Ib+uKyXtW6oLSe+RdJekRyR9dthrt9FFxA+ArwD/HEDSvvlv8XD+27xroa2kwyTdkufuA5I+lau+np+35r/3kb1xJK0Ffgs4PiKujYifRMSTEXFpRJzZZ1w/BtZR2ncW8RofBr5Yeo0XSfqcpL+S9CPgX0vaSdInJd2XX9u5kl5UGv/vSdoiabOk/9Tz2nrn9dvyvvWYpLslHS3pDOC1wDnlMw49//LO7pIuyfvSvZL+QNILct2Jkm7IY3xE0vclvXmx701dTu49JK0C3gxsKBX/CHgHxZHEW4DflPT2XHc9cFRe/lfA9/IzwOuAb8SQf+MhH5m/E3gCuCsXv5TiSGk/4BRJh1B8ALwb2BM4D7gyT/BlFEdTf563+QLw7yti7QBcBdwLrKE42ro8Iu4E3sO2o6zlfbZ9PfAx4FeBFbmPy3uavZXiqPIXcrt/M+i12+gkrQaOAW7NRZcBm4B9gWOBP5b0hlx3NnB2RPwz4ACK5AvF3ARYnv/e3+wT6g3Apoi4uea4fgY4nufvO2ORtBfFHL61VPzrwBnAbsANwMcpjvAPBg6kmMt/mLc/GvjPwJuAtcAbB8Q6DLgE+D2Kffx1wD0R8SHgG+SziYozjv8B7A7sT7HfvwM4qVR/OLAe2Av4BHDBxA54ImLJP4B7KBLr40AA11BM+qr2nwbOyssHAFspPijPpUi+m3LdxcD7Kvo4EXg6b/sQcCPwxlx3FPBTYOdS+88Bf9TTx3qKCfU6YDOgUt3fAB8t9bcwpiOBHwI7Vozphp6yi0r9XEBxCr5QtyvwT8CavB7AL5bq1wGnT/vv24VHaY5upfhQ/ROKM73VwDPAbqW2HwMuystfBz4C7NXT35r899puHpTafAi4cci4LgKeyuN6Fvg+8KqKeb7wOKKir+uAJ3ObHwCXAnuX4lxSaiuKg64DSmVHAt/PyxcCZ5bqXpFf74F95vV55P25Ykzv7CkLig+THYCfAAeV6t4NXFd67RtKdbvkbV86iTnjI/dt3h4Ru1Ekwp+j+KQFQNLhkr6WT70epTjC3QsgIu6m2OkOpjiFuwrYLOlnKRLv9QNi3hgRyyNir4g4IiL+ulT3w4h4qrS+H/D+fElma75sspriaG1f4AeRZ1B2b0XM1cC9EfH04Lejr33L/UbEE8A/UhwxLbi/tPwkxQeANePteb7sFxHvjeIyyL7AwxHxeKndvWz7m5xMkdj+n6RvacBNe0l3aNtNz9dS/G3r3ND8ZBRnemuAHwO9N+8X5vnC48YBfZ2W26yMiN+IiB+W6jaWlvemSJZ/W9of/k8uh+J9Kbev2h+g2CfuHlBfZS9gWU/f5fceSvtDRDyZFyeyTzi594iI6yk+1T9ZKv48cCWwOiJ2pzhCL59aXU9xOrwsiuuh11Ocnr0YuG3cofSsbwTO6NlJdomIy4AtwMqe072XVfS7EXiZ+t+kHfZPhG6m+JABnjsN35PiKMumYzOwh6TdSmUvI/9NIuKuiDge2IfiMsZf5L/bdn/riPj52HbT8xsUZ7CrJB1aZyARcR/Fzdezy9e+G1Qe80MUHyQ/X9ofdo/iZiwU+8TqUvuq/QGKfeKAGjF7PURx5rpfqey5937anNz7+zTwJkkLN4Z2ozg6eipfn/v1nvbXA6ey7SbVdcBvU1zieKahMf0p8J58FiFJP6PiRu9uwDcpTn1Pk7SjpF8GDqvo52aKiX9m7mNnSa/JdQ9Q7MzLKrb9PHCSpIMl7QT8MXBTRNzT0Gu0EUXERopLcB/Lf8tXURytXwog6T9I2juKm/Zb82bPUFyae5biWnFV33dRXP65TMVN+WU5xnGSTq/Y5mqKD5xTGnqJVWN7lmKfOEvSPvDcFxoW7vGsA06UdJCkXYAPD+juAop5/QZJL8j9LHyd8wEq3qO8b68DzpC0m6T9gPcB/3PRL7ABTu595FPBS4CFHzm8F/hvkh6nuGGzrmeT6yk+ABaS+w0Up4xfpyERcQvwLuAc4BGKm1Yn5rqfAr+c1x8Bfg34UkU/zwC/RHHN8D6KG3G/lquvBe4A7pf0UJ9tr6F4T75I8QFxAHBcAy/PFud4iksim4H/BXw4J1mAo4E7JD1BcXP1uIh4Kl8iOAP4v/myxhEVfZ9GMec+S/HhcDfw74D/PWA8/x34/XwA0KYPUOwHN0p6DPhr8iWhiPgKxUHatbnNtVWdRHHD+CSKr10+SrE/LxyNnw0cm7/t8pk+m/82xbX/71Hs95+nuN4/dXr+ZVozM+sCH7mbmXVQK8k9/wBgvYofVPS9Nmc2jzy3bV40flkm/0jmHyh+PLAJ+BbFL9z+vtFAZhPmuW3zpI0j98Movrj/vXyj73LgbS3EMZs0z22bG238g1Qref6PBzZR/AS3kiTf1bVWRUQTP/n23LaZUzW320ju/QJtN8ElnULL34U1a5jnts2NNpL7Jp7/y7BVFN+/fZ6IOB84H3x0Y3PDc9vmRhvX3L8FrJX08vxLx+MofrpvNu88t21uNH7kHhFPSzqV4t9E3wG4MCLuaDqO2aR5bts8mYlfqPrU1drW0A3VkXluW9uq5rZ/oWpm1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHeTkbmbWQU7uZmYdNDS5S7pQ0oOSbi+V7SHpakl35ecX53JJ+oykDZK+K+mQNgdvthie29ZldY7cLwKO7ik7HbgmItYC1+R1gDcDa/PjFOBzzQzTrBUX4bltXRURQx/AGuD20vp6YEVeXgGsz8vnAcf3azek//DDjzYfntt+dPVRNffGveb+kojYQtHzFmCfXL4S2FhqtymXbUfSKZJukXTLmGMwa4PntnXCjg33pz5l0a9hRJwPnA8gqW8bsxniuW1zZdwj9wckrQDIzw/m8k3A6lK7VcDm8YdnNnGe29YJ4x65XwmcAJyZn79cKj9V0uXA4cCjC6e4syCNWWdLylzO7aUs9TxbQfmmT3UD6TLgKGAv4AHgw8BfAuuAlwH3Ab8SEQ9LEnAOxTcQngROioih1x3bPnVNLbWdF6lieSmJiO0uqyyluV233bxJFctLSb+5DTWS+yS0uQOkltvPgzRkfSmo2gHa1tTcTk100mA/syJVLC8lVXO76RuqE5Va6nNYv6nn2awNadoDsLk2t8k9zUDchHdAa16aQr/96ga1nzVp2gOYQXP5b8ukKfXdry4N2cZsVqQx2i88bP7M1ZF7aqmvYf3WiduvTZ3tzKC9a+qponzUuKlieZrStAcw4+YmuacW+xrU92LipkVub0tDarGfQX2PGzf1PNtsmsvLMouVphAr9TzMmpYaKK9q269d78Nmy9x8FTI1HLNuf03HbaPvVLE8LEZT8efBLH8VMtWsT9RLpMPqq9r2bjdKP4sdx2L7bjPWrOvkVyF7pZ7nWY+TGuhjoZ9+y6NsV6fcmpPGaJdKz3W3r9N/k/319l1+tsma6eSexmyTBtS1MYZJ9F+3XROqYk1yDF2WGmiX+izX7XfS0pB1a8fcXnNP1Ds97ddm2HajjKFOm6biTVuiW69nViXGe49H3Sb1PI8Tb5xtx92uvP2gdSvM9DX3NGS7YfWD2tXddrHxU8VyW/HqtEsVy6NazLaTNivX3FNFu6ryOtIit6/qY1ifg+qHbbuY9r1tR43VNXP5b8ukCY6hbqy67UZpP2qfw7bv19+4MYZtN26/kzYryb0Nqc9z6tNu3H4HlVctj9rnKO166+r22VVzmdwXpAmNow1pCtv0bj9Of8NitNF/m6ad3BPNvX+97QdtP2rfdbbpV59GiFW3Xb+2VbGXsrlI7mnK42hLarl9v23SgLqmpQnEWKxZSO6zJvU8j7PtKO1Tz/o4cfptN+pYumZJfBVyVqURy9uM2Wa8Sce0xUmL3HaU7VPP82Li9lu27c1Mck/THsAUJOZ/sqYWt11M39a+NGJ5uW5Qm4X6Om2s2kxcltlXindPexAdloastxGj6faLcR6w2ZdlJi5R/zJKv7Jx2syqVLO8qt2gbX1ZpiNSzbLe+lRatslZASzVA5fUYNvU8zxom1HitrH9pGIligOXKk7ucyZNeLtR+287jnVDYvTk39s+VTwvVjlWU31Og5O7NSrVqBvUxrov9SynIW2G9VXVx2I03V9V323G8TV367xpXnP33O6+VLE8CYPm9tAjd0mrgUuAlwLPAudHxNmS9gCuANYA9wC/GhGPSBJwNnAM8CRwYkR8u4HXYTZUGqHtpOd26nm22ZZqlifaOXtYrDr/cNjTwPsj4pXAEcBvSToIOB24JiLWAtfkdYA3A2vz4xTgc6MOKo26gVmWGGn+THRujzAum7LUYPtR+2rK0CP3iNgCbMnLj0u6E1gJvA04Kje7GLgO+EAuvySK6z03SlouaUXuZ6jU89y7bIuXep67KJWWq75RMMm5nWosWzNSz/O0pSnFHemGqqQ1wKuBm4CXLEzqiNgiaZ/cbCWwsbTZplz2vB1A0ikURz/sXipPowzIxpKmPYAZ1PbcTi2N2/pLc9bvoHjjxqz977lL2hX4IvC7EfHYoKZ9yra7axsR50fEoRFx6C51B2HWAs/tbkkt9JEa6ndUqWK5jlrJXdILKSb/pRHxpVz8gKQVuX4F8GAu3wSsLm2+Ctg84rjMJsJz24ZJMxJnWH2vOt+WEXABcGdEfKpUdSVwAnBmfv5yqfxUSZcDhwOP1r3ebtZPGrNuGM9tGyS13Hdv/2lA3TjqXHN/DfAfgb+TdFsu+y8UE3+dpJOB+4BfyXV/RfFVsQ0UXxc7qYFx2hKTJhPGc9smIlHvx1vlun71g7br5R8x2dxIFcvD+EdM1jWJbf+2zNg/YjKbFWnaAzCbEalGm9rfljEzs/nh5G5m1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHeTkbmbWQU7uZmYd5ORuZtZBTu5mZh3k5G5m1kFO7mZmHTQ0uUvaWdLNkr4j6Q5JH8nlL5d0k6S7JF0haVku3ymvb8j1a9p9CWbj8dy2Lqtz5P4T4PUR8QvAwcDRko4APg6cFRFrgUeAk3P7k4FHIuJA4KzczmwWeW5bZw1N7lF4Iq++MD8CeD3wF7n8YuDteflteZ1c/wZJamzEZg3x3LYuq3XNXdIOkm4DHgSuBu4GtkbE07nJJmBlXl4JbATI9Y8Ce/bp8xRJt0i65cnFvQazsXluW1fVSu4R8UxEHAysAg4DXtmvWX7udyQT2xVEnB8Rh0bEobvUHa1Zwzy3ratG+rZMRGwFrgOOAJZL2jFXrQI25+VNwGqAXL878HATgzVri+e2dU2db8vsLWl5Xn4R8EbgTuBrwLG52QnAl/PylXmdXH9tRGx3dGM2bZ7b1mU7Dm/CCuBiSTtQfBisi4irJP09cLmkjwK3Ahfk9hcAfy5pA8VRzXEtjNusCZ7b1lmahQOPfaV497QHYZ2SetYjYirfavHctjadB2yumNt1jtzNpi71PNdpa9ZFqWY7J3ebSWlIeb/6qm3MZlmqWB7Wdhgnd5spqeF2ZtOWaiwPKhuXk7tNXZr2AMwWKVEvWfdr0xYnd5uYNO0BmI0oVSz3a5OoTvLT4ORuY0nTHoBZAxLDk3bVep1tpsnJ3QZK0x6AWYNS6Tn1Ke8SJ3fr5MS2pS2NUD+s7bxycu+gNOK62bxIA9Z765Y6J/cOStS/jmg2L1KNslRRvhQ5uS8BadoDMGtAYvQf+dTZpqv8H2R3VJr2AMxakFpu3yVO7mY2VxJLO2nX5eRuZnMpTXsAM24m/slfSY8D66cUfi/goSUUd5qxpxV3v4jYewpxpzm3Pb+WRuzKuT0rN1TXR8Sh0wgs6ZZpxJ5W3GnGnuZrnqKpzG3Pr6UTu4ovy5iZdZCTu5lZB81Kcj9/Ccb2a14aluJ77dc8A2bihqqZmTVrVo7czcysQU7uZmYdNPXkLuloSeslbZB0esN9XyjpQUm3l8r2kHS1pLvy84tzuSR9Jo/ju5IOWUTc1ZK+JulOSXdI+p0Jxt5Z0s2SvpNjfySXv1zSTTn2FZKW5fKd8vqGXL9m3Ni5vx0k3SrpqknGnTVtzuvcv+e25/ZgETG1B7ADcDewP7AM+A5wUIP9vw44BLi9VPYJ4PS8fDrw8bx8DPAVQMARwE2LiLsCOCQv7wb8A3DQhGIL2DUvvxC4Kfe5Djgul58L/GZefi9wbl4+Drhike/5+4DPA1fl9YnEnaVH2/Pac9tzu9Z4pxG09GYdCXy1tP5B4IMNx1jTswOsB1aUJur6vHwecHy/dg2M4cvAmyYdG9gF+DZwOMWv53bsfd+BrwJH5uUdczuNGW8VcA3weuCqvDO2HnfWHpOY17lfz23P7crHtC/LrAQ2ltY35bI2vSQitgDk533aHEs+JXs1xVHGRGLn08fbgAeBqymOIrdGxNN9+n8udq5/FNhzzNCfBn4feDav7zmhuLNmGvMaPLd7+1/Sc3vayV19yqb13czGxyJpV+CLwO9GxGOTih0Rz0TEwRRHG4cBrxzQfyOxJb0VeDAi/rZc3HbcGTVrr81zexGx53VuTzu5bwJWl9ZXAZtbjvmApBUA+fnBNsYi6YUUk//SiPjSJGMviIitwHUU1yWXS1r4t4TK/T8XO9fvDjw8RrjXAP9W0j3A5RSnr5+eQNxZNI15DZ7bvf0v6bk97eT+LWBtvuu8jOLmw5Utx7wSOCEvn0BxzXCh/B357v4RwKMLp5mjkiTgAuDOiPjUhGPvLWl5Xn4R8EbgTuBrwLEVsRfGdCxwbeSLhaOIiA9GxKqIWEPxd7w2In6j7bgzahrzGjy3+8VeunN70hf5+9yoOIbijvvdwIca7vsyYAvwTxSfpidTXPu6BrgrP++R2wr4bB7H3wGHLiLuL1Kchn0XuC0/jplQ7FcBt+bYtwN/mMv3B24GNgBfAHbK5Tvn9Q25fv8G3vej2PaNgonFnaVHm/Pac9tzu87D//yAmVkHTfuyjJmZtcDJ3cysg5zczcw6yMndzKyDnNzNzDrIyd3MrIOc3M3MOuj/A8M/aWn3dpxnAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure\n",
+    "plt.subplot(121)\n",
+    "plt.imshow(Y_raw.astype('uint8'))\n",
+    "plt.title('Raw Prediction')\n",
+    "plt.subplot(122)\n",
+    "plt.imshow(Y.astype('uint8'))\n",
+    "plt.title('Post-CRF Prediction')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/03_sec-dsrg/DSRG.py b/03_sec-dsrg/DSRG.py
index 8f330f3..c0028a7 100644
--- a/03_sec-dsrg/DSRG.py
+++ b/03_sec-dsrg/DSRG.py
@@ -1,4 +1,3 @@
-import os
 import numpy as np
 import tensorflow as tf
 
@@ -6,6 +5,23 @@
 from lib.CC_labeling_8 import CC_lab
 
 def single_generate_seed_step(params):
+    """Implemented seeded region growing
+
+    Parameters
+    ----------
+    params : 3-tuple of numpy 4D arrays
+        (tag) : numpy 4D array (size: B x 1 x 1 x C), where B = batch size, C = number of classes
+            GT label
+        (cue) : numpy 4D array (size: B x H_c x W_c x C), where H_c = cue height, W_c = cue width
+            Weak cue
+        (prob) : numpy 4D array (size: B x H_c x W_c x C), where H_c = cue height, W_c = cue width
+            Final feature map
+
+    Returns
+    -------
+    (cue) : numpy 4D array (size: B x H_c x W_c x C), where H_c = cue height, W_c = cue width
+            Weak cue, after seeded region growing
+    """
     # th_f,th_b = 0.85,0.99
     th_f, th_b = 0.5, 0.7
     tag, cue, prob = params
@@ -46,6 +62,8 @@ def single_generate_seed_step(params):
     return np.expand_dims(cue, axis=0)
 
 class DSRG():
+    """Class for the DSRG method"""
+
     def __init__(self, config):
         self.config = config
         self.dataset = self.config.get('dataset')
@@ -80,6 +98,26 @@ def __init__(self, config):
         self.pool = self.config.get('pool')
 
     def build(self,net_input=None,net_label=None,net_cues=None,net_id=None,phase='train'):
+        """Build DSRG model
+
+        Parameters
+        ----------
+        net_input : Tensor, optional
+            Input images in batch, after resizing and normalizing
+        net_label : Tensor, optional
+            GT segmentation in batch, after resizing
+        net_cues : Tensor, optional
+            Weak cue labels in batch, after resizing
+        net_id : Tensor, optional
+            Filenames in batch
+        phase : str, optional
+            Phase to run DSRG model
+
+        Returns
+        -------
+        (output) : Tensor
+            Final layer of FCN model of DSRG
+        """
         if "output" not in self.net:
             if phase == 'train':
                 with tf.name_scope("placeholder"):
@@ -112,6 +150,18 @@ def build(self,net_input=None,net_label=None,net_cues=None,net_id=None,phase='tr
         return self.net["output"]
 
     def create_network(self, phase):
+        """Helper function to build DSRG model
+
+        Parameters
+        ----------
+        phase : str, optional
+            Phase to run DSRG model
+
+        Returns
+        -------
+        (crf) : Tensor
+            Final layer of FCN model of DSRG
+        """
         if self.init_model_path is not None:
             self.load_init_model()
         with tf.name_scope("vgg") as scope:
@@ -127,16 +177,29 @@ def create_network(self, phase):
             fc4 = self.build_fc(block,["fc6_4","relu6_4","drop6_4","fc7_4","relu7_4","drop7_4","fc8_4"], dilate_rate=24)
             self.net["fc8"] = self.net[fc1]+self.net[fc2]+self.net[fc3]+self.net[fc4]
 
-            # SEC
+            # DSRG
             softmax = self.build_sp_softmax("fc8","fc8-softmax")
             if phase in ['train', 'debug']:
                 new_seed = self.build_dsrg_layer("cues","fc8-softmax","new_cues")
-            # crf = self.build_crf("fc8","crf") # old
             crf = self.build_crf("fc8-softmax", "crf")  # new
 
             return self.net[crf] # NOTE: crf is log-probability
 
     def build_block(self,last_layer,layer_lists):
+        """Build a block of the DSRG model
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the DSRG model
+        layer_lists : list of str
+            List of strings of layer names to build inside the current block
+
+        Returns
+        -------
+        last_layer : Tensor
+            The output layer of the current block
+        """
         for layer in layer_lists:
             if layer.startswith("conv"):
                 if layer[4] != "5":
@@ -177,6 +240,21 @@ def build_block(self,last_layer,layer_lists):
         return last_layer
 
     def build_fc(self,last_layer, layer_lists, dilate_rate=12):
+        """Build a block of fully-connected layers
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the DSRG model
+        layer_lists : list of str
+            List of strings of layer names to build inside the current block
+        dilate_rate : int, optional
+            Dilation rate for atrous 2D convolutional layers
+        Returns
+        -------
+        last_layer : Tensor
+            The output layer of the current block
+        """
         for layer in layer_lists:
             if layer.startswith("fc"):
                 with tf.name_scope(layer) as scope:
@@ -203,6 +281,19 @@ def build_fc(self,last_layer, layer_lists, dilate_rate=12):
         return last_layer
 
     def build_sp_softmax(self,last_layer,layer):
+        """Build a block of a fully-connected layer and softmax
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the DSRG model
+        layer : str
+            Name of the softmax output layer
+        Returns
+        -------
+        layer : str
+            Name of the softmax output layer
+        """
         preds_max = tf.reduce_max(self.net[last_layer],axis=3,keepdims=True)
         preds_exp = tf.exp(self.net[last_layer] - preds_max)
         self.net[layer] = preds_exp / tf.reduce_sum(preds_exp,axis=3,keepdims=True) + self.min_prob
@@ -210,6 +301,20 @@ def build_sp_softmax(self,last_layer,layer):
         return layer
 
     def build_crf(self,featmap_layer,layer):
+        """Build a custom dense CRF layer
+
+        Parameters
+        ----------
+        featemap_layer : str
+            Layer name of the feature map inputted to dense CRF layer
+        layer : str
+            Layer name of the dense CRF layer
+
+        Returns
+        -------
+        layer : str
+            Layer name of the dense CRF layer
+        """
         origin_image = self.net["input"] + self.img_mean
         origin_image_zoomed = tf.image.resize_bilinear(origin_image,(self.seed_size, self.seed_size))
         featemap = self.net[featmap_layer]
@@ -232,11 +337,23 @@ def crf(featemap,image):
         return layer
 
     def build_dsrg_layer(self,seed_layer,prob_layer,layer):
+        """Build DSRG layer
+
+        Parameters
+        ----------
+        seed_layer : str
+            Layer name of the weak cues
+        prob_layer : str
+            Layer name of softmax
+        layer : str
+            Layer name of the DSRG layer
+
+        Returns
+        -------
+        layer : str
+            Layer name of the DSRG layer
+        """
         def generate_seed_step(tags,cues,probs):
-            ''' tags shape: [-1,21]
-                cues shape: [-1,41,41,21]
-                probs shape: [-1,41,41,21]
-            '''
             tags = np.reshape(tags,[-1,1,1,self.num_classes])
 
             params_list = []
@@ -255,12 +372,27 @@ def generate_seed_step(tags,cues,probs):
         return layer
 
     def load_init_model(self):
+        """Load initialized layer"""
         model_path = self.config["init_model_path"]
         self.init_model = np.load(model_path,encoding="latin1").item()
-        print("load init model success: %s" % model_path)
 
     def get_weights_and_bias(self,layer,shape=None):
-        print("layer: %s" % layer)
+        """Load saved weights and biases for saved network
+
+        Parameters
+        ----------
+        layer : str
+            Name of current layer
+        shape : list of int (size: 4), optional
+            4D shape of the convolutional or fully-connected layer
+
+        Returns
+        -------
+        weights : Variable
+            Saved weights
+        bias : Variable
+            Saved biases
+        """
         if layer in self.weights:
             return self.weights[layer]
         if shape is not None:
@@ -313,6 +445,7 @@ def get_weights_and_bias(self,layer,shape=None):
         return weights,bias
 
     def pred(self):
+        """Implement final segmentation prediction as argmax of final feature map"""
         if self.h is not None:
             self.net["rescale_output"] = tf.image.resize_bilinear(self.net["output"], (self.h, self.w))
         else:
@@ -324,6 +457,13 @@ def pred(self):
         self.net["pred"] = tf.argmax(self.net["rescale_output"], axis=3)
 
     def getloss(self):
+        """Construct overall loss function
+
+        Returns
+        -------
+        loss : Tensor
+            Output of overall loss function
+        """
         loss = 0
         
         # for DSRG
@@ -337,6 +477,20 @@ def getloss(self):
         return loss
 
     def get_balanced_seed_loss(self,softmax,cues):
+        """Balanced seeding loss function
+
+        Parameters
+        ----------
+        softmax : Tensor
+            Final feature map
+        cues : Tensor
+            Weak cues
+
+        Returns
+        -------
+        (loss) : Tensor
+            Output of balanced seeding loss function (sum of foreground/background losses)
+        """
         count_bg = tf.reduce_sum(cues[:,:,:,0:1],axis=(1,2,3),keepdims=True)
         loss_bg = -tf.reduce_mean(tf.reduce_sum(cues[:,:,:,0:1]*tf.log(softmax[:,:,:,0:1]),axis=(1,2,3),keepdims=True)/(count_bg+1e-8))
 
@@ -345,6 +499,20 @@ def get_balanced_seed_loss(self,softmax,cues):
         return loss_bg+loss_fg
 
     def get_constrain_loss(self,softmax,crf):
+        """Constrain loss function
+
+        Parameters
+        ----------
+        softmax : Tensor
+            Final feature map
+        crf : Tensor
+            Output of dense CRF
+
+        Returns
+        -------
+        loss : Tensor
+            Output of constrain loss function
+        """
         probs_smooth = tf.exp(crf)
         loss = tf.reduce_mean(tf.reduce_sum(probs_smooth * tf.log(probs_smooth/(softmax+1e-8)+1e-8), axis=3))
         return loss
\ No newline at end of file
diff --git a/03_sec-dsrg/SEC.py b/03_sec-dsrg/SEC.py
index aedaddc..cf3baf3 100644
--- a/03_sec-dsrg/SEC.py
+++ b/03_sec-dsrg/SEC.py
@@ -3,6 +3,8 @@
 from lib.crf import crf_inference
 
 class SEC():
+    """Class for the SEC method"""
+
     def __init__(self, config):
         self.config = config
         self.dataset = self.config.get('dataset')
@@ -48,6 +50,27 @@ def __init__(self, config):
         self.pool = self.config.get('pool')
 
     def build(self,net_input=None,net_label=None,net_cues=None,net_id=None,phase='train'):
+        """Build SEC model
+
+        Parameters
+        ----------
+        net_input : Tensor, optional
+            Input images in batch, after resizing and normalizing
+        net_label : Tensor, optional
+            GT segmentation in batch, after resizing
+        net_cues : Tensor, optional
+            Weak cue labels in batch, after resizing
+        net_id : Tensor, optional
+            Filenames in batch
+        phase : str, optional
+            Phase to run SEC model
+
+        Returns
+        -------
+        (output) : Tensor
+            Final layer of FCN model of SEC
+        """
+
         if "output" not in self.net:
             if phase == 'train':
                 with tf.name_scope("placeholder"):
@@ -76,6 +99,18 @@ def build(self,net_input=None,net_label=None,net_cues=None,net_id=None,phase='tr
         return self.net["output"]
 
     def create_network(self, phase):
+        """Helper function to build SEC model
+
+        Parameters
+        ----------
+        phase : str, optional
+            Phase to run SEC model
+
+        Returns
+        -------
+        (crf) : Tensor
+            Final layer of FCN model of SEC
+        """
         if self.init_model_path is not None:
             self.load_init_model()
         with tf.name_scope("deeplab") as scope:
@@ -90,12 +125,25 @@ def create_network(self, phase):
                     fc = self.build_fc(block, ["fc6", "relu6", "fc7", "relu7", "fc8"])
         with tf.name_scope("sec") as scope:
             softmax = self.build_sp_softmax(fc)
-            # crf = self.build_crf(fc,"input")
             crf = self.build_crf(softmax, "input")
 
         return self.net[crf]
 
     def build_block(self,last_layer,layer_lists):
+        """Build a block of the SEC model
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the SEC model
+        layer_lists : list of str
+            List of strings of layer names to build inside the current block
+
+        Returns
+        -------
+        last_layer : Tensor
+            The output layer of the current block
+        """
         for layer in layer_lists:
             if layer.startswith("conv"):
                 if layer[4] != "5":
@@ -141,6 +189,20 @@ def build_block(self,last_layer,layer_lists):
         return last_layer
 
     def build_fc(self,last_layer, layer_lists):
+        """Build a block of fully-connected layers
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the SEC model
+        layer_lists : list of str
+            List of strings of layer names to build inside the current block
+
+        Returns
+        -------
+        last_layer : Tensor
+            The output layer of the current block
+        """
         for layer in layer_lists:
             if layer.startswith("fc"):
                 with tf.name_scope(layer) as scope:
@@ -168,6 +230,18 @@ def build_fc(self,last_layer, layer_lists):
         return last_layer
 
     def build_sp_softmax(self,last_layer):
+        """Build a block of a fully-connected layer and softmax
+
+        Parameters
+        ----------
+        last_layer : Tensor
+            The most recent layer used to build the SEC model
+
+        Returns
+        -------
+        layer : Tensor
+            The output layer of the current block
+        """
         layer = "fc8-softmax"
         preds_max = tf.reduce_max(self.net[last_layer],axis=3,keepdims=True)
         preds_exp = tf.exp(self.net[last_layer] - preds_max)
@@ -175,16 +249,27 @@ def build_sp_softmax(self,last_layer):
         self.net[layer] = self.net[layer] / tf.reduce_sum(self.net[layer],axis=3,keepdims=True)
         return layer
 
-
     def build_crf(self,featemap_layer,img_layer):
+        """Build a custom dense CRF layer
+
+        Parameters
+        ----------
+        featemap_layer : str
+            Layer name of the feature map inputted to dense CRF layer
+        img_layer : str
+            Layer name of the input image
+
+        Returns
+        -------
+        layer : str
+            Layer name of the dense CRF layer
+        """
         origin_image = self.net[img_layer] + self.img_mean
         origin_image_zoomed = tf.image.resize_bilinear(origin_image,(self.seed_size,self.seed_size))
         featemap = self.net[featemap_layer]
         def crf(featemap,image):
             batch_size = featemap.shape[0]
             image = image.astype(np.uint8)
-            # print('shape of featemap = ' + str(featemap.shape))
-            # print('shape of image = ' + str(image.shape))
             ret = np.zeros(featemap.shape,dtype=np.float32)
             for i in range(batch_size):
                 ret[i, :, :, :] = crf_inference(image[i], self.crf_config_train, self.num_classes, featemap[i],
@@ -199,19 +284,25 @@ def crf(featemap,image):
         return layer
 
     def load_init_model(self):
+        """Load initialized layer"""
         model_path = self.config["init_model_path"]
         self.init_model = np.load(model_path,encoding="latin1").item()
-        print("load init model success: %s" % model_path)
 		
-    def restore_from_model(self,saver,model_path,checkpoint=False):
-        assert self.sess is not None
-        if checkpoint is True:
-            ckpt = tf.train.get_checkpoint_state(model_path)
-            saver.restore(self.sess, ckpt.model_checkpoint_path)
-        else:
-            saver.restore(self.sess, model_path)
-			
     def get_weights_and_bias(self,layer):
+        """Load saved weights and biases for saved network
+
+        Parameters
+        ----------
+        layer : str
+            Name of current layer
+
+        Returns
+        -------
+        weights : Variable
+            Saved weights
+        bias : Variable
+            Saved biases
+        """
         if layer.startswith("conv"):
             shape = [3,3,0,0]
             if layer == "conv1_1":
@@ -258,6 +349,7 @@ def get_weights_and_bias(self,layer):
         return weights,bias
 
     def pred(self):
+        """Implement final segmentation prediction as argmax of final feature map"""
         if self.h is not None:
             self.net["rescale_output"] = tf.image.resize_bilinear(self.net["output"], (self.h, self.w))
         else:
@@ -269,6 +361,13 @@ def pred(self):
         self.net["pred"] = tf.argmax(self.net["rescale_output"], axis=3)
 
     def getloss(self):
+        """Construct overall loss function
+
+        Returns
+        -------
+        loss : Tensor
+            Output of overall loss function
+        """
         seed_loss = self.get_seed_loss(self.net["fc8-softmax"],self.net["cues"])
         expand_loss = self.get_expand_loss(self.net["fc8-softmax"],self.net["label"])
         constrain_loss = self.get_constrain_loss(self.net["fc8-softmax"],self.net["crf"])
@@ -281,11 +380,39 @@ def getloss(self):
         return loss
 
     def get_seed_loss(self,softmax,cues):
+        """Seeding loss function
+
+        Parameters
+        ----------
+        softmax : Tensor
+            Final feature map
+        cues : Tensor
+            Weak cues
+
+        Returns
+        -------
+        loss : Tensor
+            Output of seeding loss function
+        """
         count = tf.math.maximum(tf.reduce_sum(cues,axis=(1,2,3),keepdims=True), 1e-5)
         loss = -tf.reduce_mean(tf.reduce_sum( cues*tf.log(softmax), axis=(1,2,3), keepdims=True)/count)
         return loss
 
     def get_expand_loss(self,softmax,labels):
+        """Expand loss function
+
+        Parameters
+        ----------
+        softmax : Tensor
+            Final feature map
+        labels : Tensor
+            GT labels
+
+        Returns
+        -------
+        loss : Tensor
+            Output of expand loss function
+        """
         stat = labels[:,1:]
         probs_bg = softmax[:,:,:,0]
         probs = softmax[:,:,:,1:]
@@ -319,6 +446,20 @@ def get_expand_loss(self,softmax,labels):
         return loss
 
     def get_constrain_loss(self,softmax,crf):
+        """Constrain loss function
+
+        Parameters
+        ----------
+        softmax : Tensor
+            Final feature map
+        crf : Tensor
+            Output of dense CRF
+
+        Returns
+        -------
+        loss : Tensor
+            Output of constrain loss function
+        """
         probs_smooth = tf.exp(crf)
         loss = tf.reduce_mean(tf.reduce_sum(probs_smooth * tf.log(probs_smooth/softmax), axis=3))
         return loss
\ No newline at end of file
diff --git a/03_sec-dsrg/model.py b/03_sec-dsrg/model.py
index b66b1d0..831c834 100644
--- a/03_sec-dsrg/model.py
+++ b/03_sec-dsrg/model.py
@@ -19,6 +19,8 @@
 MODEL_WSSS_ROOT = '../database/models_wsss'
 
 class Model():
+    """Wrapper class for SEC and DSRG WSSS methods"""
+
     def __init__(self, args):
         self.method = args.method
         self.dataset = args.dataset
@@ -33,6 +35,7 @@ def __init__(self, args):
         self.seed_size = 41
         self.batch_size = args.batchsize
         self.should_saveimg = args.saveimg
+        self.verbose = args.verbose
 
         self.accum_num = 1
         self.pool = multiprocessing.Pool()
@@ -104,10 +107,6 @@ def __init__(self, args):
             elif self.dataset == 'DeepGlobe_train37.5':
                 self.input_path = os.path.join(self.dataset_dir, 'ImageSets', 'Segmentation', 'input_list_train37.5.txt')
             self.run_categories = ['test']
-            # if 'DeepGlobe2' in self.dataset:
-            #     self.run_categories = ['test']
-            # else:
-            #     self.run_categories = ['val']
             self.class_names = ['urban', 'agriculture', 'rangeland', 'forest', 'water', 'barren']
             self.label2rgb_colors = np.array([(0, 255, 255), (255, 255, 0), (255, 0, 255), (0, 255, 0), (0, 0, 255),
                         (255, 255, 255)])
@@ -119,6 +118,7 @@ def __init__(self, args):
         self.run_categories = ['train'] + self.run_categories
         self.data_f, self.data_len = self.get_data_f(self.run_categories)
     def load(self):
+        """Load either SEC or DSRG model"""
         if self.method == 'DSRG':
             self.model = DSRG({'dataset': self.dataset, 'img_size': self.h, 'num_classes': self.num_classes,
                                'batch_size': self.batch_size, 'phase': self.phase, 'img_mean': self.img_mean,
@@ -128,6 +128,13 @@ def load(self):
                               'batch_size': self.batch_size, 'phase': self.phase, 'img_mean': self.img_mean,
                               'seed_size': self.seed_size, 'pool': self.pool, 'init_model_path': self.init_model_path})
     def get_data_f(self, phases):
+        """Load names of files in the dataset
+
+        Parameters
+        ----------
+        phases : list of str
+            The phases to run the Model object on
+        """
         # cues_labels = [self.cues_data[x] for i, x in enumerate(self.cues_data.keys()) if '_labels' in x]
         # [i for i,x in enumerate(cues_labels) if 32 in x]
         cues_root = os.path.join(os.path.dirname(os.getcwd()), '01_weak_cues')
@@ -168,10 +175,31 @@ def get_data_f(self, phases):
                                 os.path.join(self.dataset_dir, "SegmentationClassAug", self.dataset, "%s.png" % line))
                 data_len[phase] = len(data_f[phase]["id"])
                 data_len[phase] = len(data_f[phase]["label"])
-        print("len:%s" % str(data_len))
+        if self.verbose:
+            print("len:%s" % str(data_len))
         return data_f,data_len
 
     def next_batch(self,category=None,max_epochs=-1):
+        """Load next batch in the dataset for running
+
+        Parameters
+        ----------
+        category : str, optional
+            The category to run the Model object in
+        max_epochs : int, optional
+            The maximum number of epochs to run the Model object before terminating
+
+        Returns
+        -------
+        img : Tensor
+            Input images in batch, after resizing and normalizing
+        label : Tensor
+            GT segmentation in batch, after resizing
+        id : Tensor
+            Filenames in batch
+        iterator : Iterator
+            Iterator object through dataset
+        """
         self.category = category
         def m_train(x):
             id_ = x["id"]
@@ -221,7 +249,6 @@ def m_val(x):
                 "id":self.data_f[category]["id"],
                 "id_for_slice":self.data_f[category]["id_for_slice"],
                 "img_f":self.data_f[category]["img"],
-                #"gt_f":self.data_f[category]["gt"],
                 })
             dataset = dataset.repeat(max_epochs)
             dataset = dataset.shuffle(self.data_len[category])
@@ -239,7 +266,6 @@ def m_val(x):
                 "label_f": self.data_f[category]["label"]
             })
             dataset = dataset.repeat(max_epochs)
-            # dataset = dataset.shuffle(self.data_len[category])
             dataset = dataset.map(m_val)
             dataset = dataset.batch(self.batch_size)
             iterator = dataset.make_initializable_iterator()
@@ -248,6 +274,22 @@ def m_val(x):
             return img, label, id, iterator
 
     def image_preprocess(self, img, label=None):
+        """Load next batch in the dataset for running
+
+        Parameters
+        ----------
+        img : Tensor
+            Input images in batch, before resizing and normalizing
+        label : Tensor, optional
+            GT segmentation in batch, before resizing
+
+        Returns
+        -------
+        img : Tensor
+            Input images in batch, after resizing and normalizing
+        label : Tensor
+            GT segmentation in batch, after resizing
+        """
         if self.category in ['train', 'debug']:
             img = tf.expand_dims(img,axis=0)
             img = tf.image.resize_bilinear(img,(self.h,self.w))
@@ -273,12 +315,6 @@ def image_preprocess(self, img, label=None):
                 label = tf.expand_dims(label, axis=0)
                 label = tf.image.resize_nearest_neighbor(label, (self.h, self.w))
                 label = tf.squeeze(label, axis=0)
-                # label -= self.ignore_label
-                # label = tf.squeeze(label, squeeze_dims=[0])
-                # label += self.ignore_label
-                # label = tf.expand_dims(label, axis=0)
-                # label = tf.image.resize_nearest_neighbor(label, (self.h, self.w))
-                # label = tf.squeeze(label, axis=0)
 
             r, g, b = tf.split(axis=2, num_or_size_splits=3, value=img)
             img = tf.cast(tf.concat([b, g, r], 2), dtype=tf.float32)
@@ -287,6 +323,27 @@ def image_preprocess(self, img, label=None):
             return img, label
 
     def label2rgb(self, label, category_num, colors=[], ignore_label=128, ignore_color=(255,255,255)):
+        """Convert index labels to RGB colour images
+
+        Parameters
+        ----------
+        label : numpy 2D array (size: H x W)
+            The index label map, with each array element equal to the class index at that position
+        category_num : int
+            The number of classes
+        colours : numpy 1D array of 3-tuples of int
+            List of colours for each class
+        ignore_label : int
+            Class index to ignore as background
+        ignore_color : 3-tuple of int
+            Class colour to ignore as background
+
+        Returns
+        -------
+        (label_uint8) : numpy 2D array (size: H x W x 3)
+            The label map, as a colour RGB image
+        """
+
         if len(colors) <= 0:
             index = np.unique(label)
             index = index[index < category_num]
@@ -294,34 +351,8 @@ def label2rgb(self, label, category_num, colors=[], ignore_label=128, ignore_col
         label = imgco.label2rgb(label, colors=colors, bg_label=ignore_label, bg_color=ignore_color)
         return label.astype(np.uint8)
 
-    def optimize(self):
-        for val_category in self.run_categories[1:]:
-            self.model.metric["miou_" + val_category] = tf.Variable(0.0, trainable=False)
-        self.model.loss["norm"] = self.model.getloss()
-        self.model.loss["l2"] = sum([tf.nn.l2_loss(self.model.weights[layer][0]) for layer in self.model.weights])
-        self.model.loss["total"] = self.model.loss["norm"]+ self.weight_decay * self.model.loss["l2"]
-        self.model.net["lr"] = tf.Variable(self.base_lr, trainable=False)
-        opt = tf.train.MomentumOptimizer(self.model.net["lr"], self.momentum)
-        gradients = opt.compute_gradients(self.model.loss["total"])
-        self.model.net["accum_gradient"] = []
-        self.model.net["accum_gradient_accum"] = []
-        new_gradients = []
-        for (g,v) in gradients:
-            if g is None: continue
-            if v in self.model.lr_2_list:
-                g = 2*g
-            if v in self.model.lr_10_list:
-                g = 10*g
-            if v in self.model.lr_20_list:
-                g = 20*g
-            self.model.net["accum_gradient"].append(tf.Variable(tf.zeros_like(g),trainable=False))
-            self.model.net["accum_gradient_accum"].append(self.model.net["accum_gradient"][-1].assign_add( g/self.accum_num, use_locking=True))
-            new_gradients.append((self.model.net["accum_gradient"][-1],v))
-
-        self.model.net["accum_gradient_clean"] = [g.assign(tf.zeros_like(g)) for g in self.model.net["accum_gradient"]]
-        self.model.net["accum_gradient_update"]  = opt.apply_gradients(new_gradients)
-
     def get_latest_checkpoint(self):
+        """Find the filepath to the saved model checkpoint"""
         if 'final-0.index' in os.listdir(self.save_dir):
             return os.path.join(self.save_dir, 'final-0')
         all_checkpoint_inds = [int(x.split('.')[0].split('-')[-1]) for x in os.listdir(self.save_dir) if
@@ -331,17 +362,22 @@ def get_latest_checkpoint(self):
         latest_checkpoint = os.path.join(self.save_dir, 'epoch-' + str(max(all_checkpoint_inds)))
         return latest_checkpoint
 
-    def restore_from_model(self,saver,model_path,checkpoint=False):
+    def restore_from_model(self,saver,model_path):
+        """Restore model from saved checkpoint
+
+        Parameters
+        ----------
+        saver : Saver
+            The Saver object used to load the model
+        model_path : str
+            The file path to the saved checkpoint
+        """
         assert self.sess is not None
-        if checkpoint is True:
-            ckpt = tf.train.get_checkpoint_state(model_path)
-            saver.restore(self.sess, ckpt.model_checkpoint_path)
-        else:
-            saver.restore(self.sess, model_path)
+        saver.restore(self.sess, model_path)
 
     def predict(self):
+        """Predict the segmentation for the requested dataset"""
         tf.reset_default_graph()
-        # self.sess = tf.Session()
         config = tf.ConfigProto()
         config.gpu_options.per_process_gpu_memory_fraction = 1.0
         self.sess = tf.Session(config=config)
@@ -365,8 +401,9 @@ def predict(self):
         self.saver = tf.train.Saver(max_to_keep=1, var_list=self.model.trainable_list)
         latest_ckpt = self.get_latest_checkpoint()
         if latest_ckpt is not None:
-            print('Loading model from previous checkpoint %s' % latest_ckpt)
-            self.restore_from_model(self.saver, latest_ckpt, checkpoint=False)
+            if self.verbose:
+                print('Loading model from previous checkpoint %s' % latest_ckpt)
+            self.restore_from_model(self.saver, latest_ckpt)
 
         # Create save image directory if non-existent
         layers = ['rescale_output']
@@ -378,9 +415,17 @@ def predict(self):
                 miou_val = self.eval_miou(data_x[val_category], id_of_image[val_category], data_label[val_category],
                                           self.model.net['input'], self.model.net[layer], self.model.net['drop_prob'],
                                           val_category, saveimg_dir, should_overlay=True, is_eval=True)
-                print('mIoU [%s] = %f' % (val_category, miou_val))
+                if self.verbose:
+                    print('mIoU [%s] = %f' % (val_category, miou_val))
 
     def single_crf_metrics(self, params):
+        """Run dense CRF and save results to file
+
+        Parameters
+        ----------
+        params : tuple
+            Contains the settings for running dense CRF and saving segmentation results to file
+        """
         img, featmap, category_num, id_, output_dir, should_overlay = params
         if 'DeepGlobe' in self.dataset:
             img = cv2.resize(img, (img.shape[0] // 4, img.shape[1] // 4))
@@ -400,7 +445,36 @@ def single_crf_metrics(self, params):
                                                                                        category_num))
 
     def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_dir, should_overlay=False, is_eval=False):
-        print('Evaluating mIoU on [%s] set' % val_category)
+        """Convert index labels to RGB colour images
+
+        Parameters
+        ----------
+        data : Tensor
+            Input images in batch, after resizing and normalizing
+        id : Tensor
+            Filenames in batch
+        gt : Tensor
+            GT segmentation in batch
+        input : Layer
+            Input layer of the network
+        dropout : Dropout
+            Dropout variable in the network
+        val_category : str
+            Name of validation set
+        saveimg_dir : str
+            Directory to save the debug images
+        should_overlay : bool, optional
+            Whether to overlay segmentation on original image
+        is_eval : bool, optional
+            Whether currently predicting on evaluation set
+
+        Returns
+        -------
+        mIoU : float
+            The mIoU of the complete evaluation set
+        """
+        if self.verbose:
+            print('Evaluating mIoU on [%s] set' % val_category)
         intersect = np.zeros((self.num_classes))
         union = np.zeros((self.num_classes))
         confusion_matrix = np.zeros((self.num_classes, self.num_classes))
@@ -410,21 +484,27 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
         img_ids = []
         try:
             while True:
+                # Read the input images, filenames, and GT segmentations in current batch
                 img,id_,gt_ = self.sess.run([data,id,gt])
+                # Generate predicted segmentation in current batch
                 output_scale = self.sess.run(layer,feed_dict={input:img, dropout:0.0})
                 img_ids += list(id_)
                 gt_ = gt_[:, :, :, :3]
                 i += 1
-                print('\tBatch #%d of %d' % (i, self.data_len[val_category] // self.batch_size + 1), end='')
+                if self.verbose:
+                    print('\tBatch #%d of %d' % (i, self.data_len[val_category] // self.batch_size + 1), end='')
                 start_time = time.time()
+                # Iterate through images in batch
                 for j in range(img.shape[0]):
                     if not is_eval:
                         img_curr = np.uint8(img[j] + self.img_mean)
                         gt_curr = np.uint8(gt_[j])
                         pred_curr = output_scale[j]
                     else:
+                        # Read original image
                         img_curr = cv2.cvtColor(cv2.imread(os.path.join(self.dataset_dir, 'JPEGImages',
                                                 id_[j].decode('utf-8') + '.jpg')), cv2.COLOR_RGB2BGR)
+                        # Read GT segmentation
                         if self.dataset == 'VOC2012' or 'DeepGlobe' in self.dataset:
                             gt_curr = cv2.cvtColor(cv2.imread(os.path.join(self.dataset_dir, 'SegmentationClassAug',
                                                           id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)
@@ -434,6 +514,7 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
                         elif self.dataset == 'ADP-func':
                             gt_curr = cv2.cvtColor(cv2.imread(os.path.join(self.dataset_dir, 'SegmentationClassAug', 'ADP-func',
                                                               id_[j].decode('utf-8') + '.png')), cv2.COLOR_RGB2BGR)
+                        # Read predicted segmentation
                         if 'DeepGlobe' not in self.dataset:
                             pred_curr = cv2.resize(output_scale[j], (gt_curr.shape[1], gt_curr.shape[0]))
                             img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))
@@ -446,6 +527,7 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
                                                       output_scale[j], use_log=True)
                             pred_curr = cv2.resize(pred_curr, (gt_curr.shape[1], gt_curr.shape[0]))
                             img_curr = cv2.resize(img_curr, (gt_curr.shape[1], gt_curr.shape[0]))
+                    # Evaluate predicted segmentation
                     if self.dataset == 'VOC2012':
                         pred_count += np.bincount(np.argmax(pred_curr, axis=-1).ravel(), minlength=self.num_classes)
                         for k in range(pred_curr.shape[2]):
@@ -454,7 +536,6 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
                             confusion_matrix[k, :] += np.bincount(np.argmax(pred_curr[gt_mask], axis=-1),
                                                                   minlength=self.num_classes)
                             gt_count[k] += np.sum(gt_mask)
-                            #
                             intersect[k] += np.sum(gt_mask & pred_mask)
                             union[k] += np.sum(gt_mask | pred_mask)
                     elif self.dataset in ['ADP-morph', 'ADP-func'] or 'DeepGlobe' in self.dataset:
@@ -467,7 +548,6 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
                             pred_mask = np.argmax(pred_curr, axis=-1) == k
                             confusion_matrix[k, :] += np.bincount(np.argmax(pred_curr[gt_mask], axis=-1), minlength=self.num_classes)
                             gt_count[k] += np.sum(gt_mask)
-                            #
                             intersect[k] += np.sum(gt_mask & pred_mask)
                             union[k] += np.sum(gt_mask | pred_mask)
                     # Save image
@@ -479,17 +559,20 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
                         params = (img_curr, pred_curr, self.num_classes, id_[j].decode(),
                                   saveimg_dir, should_overlay)
                         self.single_crf_metrics(params)
-                print('\t\tElapsed time (s): %s' % (time.time() - start_time))
+                if self.verbose:
+                    print('\t\tElapsed time (s): %s' % (time.time() - start_time))
         except tf.errors.OutOfRangeError:
             print('Done evaluating mIoU on validation set')
         except Exception as e:
-            print("exception info:%s" % traceback.format_exc())
+            print("Exception info:%s" % traceback.format_exc())
+        # Evaluate mIoU and save to .xlsx file
         mIoU = np.mean(intersect / (union + 1e-7))
         if is_eval:
             df = pd.DataFrame({'Class': self.class_names + ['Mean'], 'IoU': list(intersect / (union + 1e-7)) + [mIoU]},
                               columns=['Class', 'IoU'])
             xlsx_path = os.path.join(self.eval_dir, 'metrics_' + self.dataset + '_' + val_category + '-' + self.seed_type + '.xlsx')
             df.to_excel(xlsx_path)
+        # Save confusion matrix for all classes to .png file
         count_mat = np.transpose(np.matlib.repmat(gt_count, self.num_classes, 1))
         np.savetxt(os.path.join(self.eval_dir, 'confusion_' + self.dataset + '_' + val_category + '-' + self.seed_type + '.csv'),
                    confusion_matrix / count_mat)
@@ -501,7 +584,7 @@ def eval_miou(self, data, id, gt, input, layer, dropout, val_category, saveimg_d
         heatmap(confusion_matrix / count_mat, title, xlabel, ylabel, xticklabels, yticklabels, rot_angle=45)
         plt.savefig(os.path.join(self.eval_dir, 'confusion_' + self.dataset + '_' + val_category + '.png'), dpi=96, format='png', bbox_inches='tight')
         plt.close()
-
+        # Save confusion matrix for only foreground classes to .png file
         title = "Confusion matrix\n"
         xlabel = 'Prediction'  # "Labels"
         ylabel = 'Ground-Truth'  # "Labels"
diff --git a/README.md b/README.md
index cd31865..6f27f8d 100644
--- a/README.md
+++ b/README.md
@@ -3,11 +3,11 @@
 ## Introduction
 ![](/methods.png)
 
-We conduct the first comprehensive analysis of Weakly-Supervised Semantic Segmentation (WSSS) with image label supervision in different image domains (submitted to IJCV [pre-print](https://arxiv.org/abs/1912.11186)). WSSS has been almost exclusively evaluated on PASCAL VOC2012 but little work has been done on applying to different image domains, such as histopathology and satellite images. The paper analyzes the compatibility of different methods for representative datasets and presents principles for applying to an unseen dataset.
+We conduct the first comprehensive analysis of Weakly-Supervised Semantic Segmentation (WSSS) with image label supervision in different image domains (submitted to IJCV: [pre-print](https://arxiv.org/abs/1912.11186)). WSSS has been almost exclusively evaluated on PASCAL VOC2012 but little work has been done on applying to different image domains, such as histopathology and satellite images. The paper analyzes the compatibility of different methods for representative datasets and presents principles for applying to an unseen dataset.
 
 ![](/method.png)
 
-We have provided the evaluation code used to generate the weak localization cues and final segmentations from Section 5 (Performance Evaluation) of the paper for reproducing our results. Pretrained models and evaluation images are also available for download.
+In this repository, we provide the evaluation code used to generate the weak localization cues and final segmentations from Section 5 (Performance Evaluation) of the paper. The code release enables reproducing the results in our paper. Pretrained models and evaluation images are also available for download.
 
 ## Citing this repository
 
@@ -22,7 +22,6 @@ If you find this code useful in your research, please consider citing us:
             primaryClass={cs.CV}
         }
 
-
 ## Getting Started
 
 These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
@@ -47,12 +46,13 @@ Optional
 
 ## Downloading data
 
-Download `wsss-analysis_data.zip` (? GB) from OneDrive containing pretrained models, ground-truth annotations, and images [here](link) and extract the contents into your `wsss-analysis\database` directory.
+Download `wsss-analysis_data.zip` (9.9 GB) from Google Drive containing pretrained models, ground-truth annotations, and images [here](https://drive.google.com/file/d/1D77LEFqmaeRDqoz4nPipTmJI03377mr2/view?usp=sharing) and extract the contents into your `wsss-analysis\database` directory.
 
 Note: the training-set images of ADP are released on a case-by-case basis due to the confidentiality agreement for releasing the data. To obtain access to `wsss-analysis\database\ADPdevkit\ADPRelease1\JPEGImages` and `wsss-analysis\database\ADPdevkit\ADPRelease1\PNGImages` needed for `gen_cues` in `01_weak_cues`, apply for access separately [here](http://www.dsp.utoronto.ca/projects/ADP/ADP_Database/).
 
 ## Running the code
 
+### Scripts
 To run `01_weak_cues` (cues performance in Section 5):
 ```
 python 01_weak_cues/demo.py
@@ -68,11 +68,21 @@ To run `03_sec-dsrg` (SEC, DSRG performance in Section 5):
 ./run_all.sh
 ```
 
-## Notebooks
+### Notebooks
+
+`02_hsn_v1_lean`:
+* VGG16-HistoSegNet on ADP: [02_hsn_v1_lean/02_hsn_v1_lean-adp.ipynb](02_hsn_v1_lean/02_hsn_v1_lean-adp.ipynb)
+* VGG16-HistoSegNet on VOC2012: [02_hsn_v1_lean/02_hsn_v1_lean-voc2012.ipynb](02_hsn_v1_lean/02_hsn_v1_lean-voc2012.ipynb)
+* VGG16-HistoSegNet on DeepGlobe: [02_hsn_v1_lean/02_hsn_v1_lean-deepglobe.ipynb](02_hsn_v1_lean/02_hsn_v1_lean-deepglobe.ipynb)
 
-(Notebooks showing segmentation results here)
+`03_sec-dsrg`:
+* VGG16-SEC on ADP-morph: [03_sec-dsrg/03_sec-adp-morph.ipynb](03_sec-dsrg/03_sec-adp-morph.ipynb)
+* VGG16-SEC on ADP-func: [03_sec-dsrg/03_sec-adp-func.ipynb](03_sec-dsrg/03_sec-adp-func.ipynb)
+* VGG16-SEC on VOC2012: [03_sec-dsrg/03_sec-voc2012.ipynb](03_sec-dsrg/03_sec-voc2012.ipynb)
+* VGG16-SEC on DeepGlobe: [03_sec-dsrg/03_sec-deepglobe.ipynb](03_sec-dsrg/03_sec-deepglobe.ipynb)
 
 ## Results
+(NOTE: some numerical results differ slightly from those reported in the paper due to a minor variation in the way the Grad-CAM gradients are normalized for X1.7/M7-HistoSegNet. See [hsn_v1](https://github.com/lyndonchan/hsn_v1) to replicate those results for ADP precisely.)
 
 | Seeding   Network | -         | -       | VGG16    | -        | -        | -           | X1.7/M7  | -        | -        | -           |
 |-------------------|-----------|---------|----------|----------|----------|-------------|----------|----------|----------|-------------|
diff --git a/methods.png b/methods.png
new file mode 100644
index 0000000..a423c92
Binary files /dev/null and b/methods.png differ