Merge pull request #6 from coreyjadams/tf-1.X

Tf 1.x

Author: coreyjadams

bin/exec.py

@@ -1,7 +1,7 @@
 numpy
 h5py
 larcv
-tensorflow==1.15.0
+tensorflow==2.0.0
 torch==1.3
 Pillow # Needed for tensorboardX
 tensorboardX

requirements.txt

@@ -0,0 +1,122 @@
+
+
+# This function is to parse strings from argparse into bool
+def str2bool(v):
+    '''Convert string to boolean value
+
+    This function is from stackoverflow:
+    https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
+
+    Arguments:
+        v {str} -- [description]
+
+    Returns:
+        bool -- [description]
+
+    Raises:
+        argparse -- [description]
+    '''
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+
+class UResNetConfig(object):
+
+    def __init__(self):
+        self._name = "UResNet"
+        self._help = "Tensorflow Implementation of multi-plane UResNet"
+
+    def build_parser(self, parser):
+
+        ##################################################################
+        # Parameters to control the network implementation
+        ##################################################################
+
+        # Layerwise parameters:
+        parser.add_argument('-ub','--use-bias', 
+            type    = str2bool, 
+            default = True,
+            help    = "Whether or not to include bias terms in all learned layers.")
+
+        parser.add_argument('-bn','--batch-norm', 
+            type    = str2bool, 
+            default = True,
+            help    = "Whether or not to use batch normalization in all mlp layers.")
+
+        # Network Architecture parameters:
+        parser.add_argument('--n-initial-filters', 
+            type    = int, 
+            default = 16,
+            help    = "Number of filters applied, per plane, for the initial convolution.")
+
+        parser.add_argument('--blocks-per-layer', 
+            type    = int, 
+            default = 2,
+            help    = "Number of blocks per layer.")
+
+        parser.add_argument('--blocks-deepest-layer', 
+            type    = int, 
+            default = 5,
+            help    = "Number of blocks applied at the deepest, merged layer.")
+
+        parser.add_argument('--blocks-final', 
+            type    = int, 
+            default = 0,
+            help    = "Number of blocks applied at full, final resolution.")
+
+        parser.add_argument('--network-depth', 
+            type    = int, 
+            default = 6,
+            help    = "Total number of downsamples to apply. Note: ensure depth + downsample =< 8")
+
+        parser.add_argument("--filter-size-deepest", 
+            type    = int, 
+            default = 5,
+            help    = "Convolutional window size for the deepest layer convolution.")
+
+        parser.add_argument("--bottleneck-deepest", 
+            type    = int, 
+            default = 256,
+            help    = "Bottleneck size for deepest layer convolution.")
+
+        parser.add_argument('--connections', 
+            type    = str, 
+            choices = ['sum', 'concat', 'none'], 
+            default = 'sum',
+            help    = "Connect shortcuts with sums, concat+bottleneck, or no connections.")
+
+        parser.add_argument('--upsampling', 
+            type    = str,
+            choices = ["convolutional", "interpolation"], 
+            default = "interpolation",
+            help    = "Which operation to use for upsamplign.")
+
+        parser.add_argument('--downsampling', 
+            type    = str,
+            choices = ["convolutional", "max_pooling"], 
+            default = "max_pooling",
+            help    = "Which operation to use for downsamplign.")
+
+        parser.add_argument('--residual', 
+            type    = str2bool, 
+            default = True,
+            help    = "Use residual units instead of convolutions.")
+
+
+        parser.add_argument('-gr', '--growth-rate', 
+            type    = str, 
+            choices = ['multiplicative','additive'], 
+            default = "additive",
+            help    = "Either double at each layer, or add a constant factor, to the number of filters.")
+
+        parser.add_argument('--block-concat', 
+            type    = str2bool, 
+            default = False,
+            help    = "Block the concatenations at the deepest layer (2D only).")
+
+
+

src/io/io_templates.py

@@ -0,0 +1,70 @@
+import tensorflow as tf
+from tensorflow.python.keras.utils import losses_utils
+
+import numpy
+
+class AccuracyCalculator(object):
+
+    def __init__(self):
+
+        object.__init__(self)
+
+
+    def __call__(self, labels, prediction):
+
+        # Labels is a list of tensors
+        # Logits is a list of tensors
+        with tf.name_scope("accuracy"):
+            n_planes = 3
+            accuracies = {
+                "total_accuracy"   : [None]*n_planes,
+                "non_bkg_accuracy" : [None]*n_planes,
+                "neut_iou"         : [None]*n_planes,
+                "cosmic_iou"       : [None]*n_planes
+            }
+
+            for p in range(n_planes):
+            # for p in range(n_planes):
+
+                # Accuracy over individual pixels:
+                pixel_accuracy = tf.stop_gradient(tf.cast(tf.math.equal(labels[p], prediction[p]), dtype=tf.float32))
+
+                accuracies["total_accuracy"][p] = tf.reduce_mean(pixel_accuracy)
+
+                # Find the non zero labels:
+                non_zero_indices = tf.cast(tf.not_equal(labels[p], tf.constant(0, labels[p].dtype)), tf.float32)
+
+
+
+                weighted_accuracy = pixel_accuracy * non_zero_indices
+
+                # Use non_zero_indexes to mask the accuracy to non zero label pixels
+                accuracies["non_bkg_accuracy"][p] = tf.reduce_sum(weighted_accuracy) / tf.reduce_sum(non_zero_indices)
+
+
+                # Neutrinos are label 2, cosmics label 1.  But iterate so I only need to
+                # write these metrics once:
+
+                for index in [1, 2]:
+                    # Find the true indices:
+                    label_indices       = tf.equal(
+                        labels[p], tf.constant(index, labels[p].dtype))
+                    # Find the predicted indices:
+                    prediction_indices  = tf.equal(
+                        prediction[p], tf.constant(index, prediction[p].dtype))
+
+
+                    # To compute the intersection over union metrics,
+                    # start with intersections and unions:
+                    intersection = tf.math.logical_and(label_indices, prediction_indices)
+                    union        = tf.math.logical_or(label_indices, prediction_indices)
+
+                    iou = tf.reduce_sum(tf.cast(intersection, tf.float32)) / tf.reduce_sum(tf.cast(union, tf.float32))
+                    if index == 1:
+                        accuracies['cosmic_iou'][p] = iou
+                    else :
+                        accuracies['neut_iou'][p]   = iou
+
+
+
+            return accuracies