Improve handling of model parameters

Before this commit the model parameters were stored as numpy array. Now the  model parameters are
converted to a tensorflow variable.

Author: berleon

deeplift/conversion/kerasapi_conversion.py

@@ -446,23 +446,25 @@ def convert_sequential_model(
               +str(nonlinear_mxts_mode))
         sys.stdout.flush()
 
-    converted_layers = []
-    batch_input_shape = model_config[0]['config'][KerasKeys.batch_input_shape]
-    converted_layers.append(
-        layers.core.Input(batch_shape=batch_input_shape, name="input"))
-    #converted_layers is actually mutated to be extended with the
-    #additional layers so the assignment is not strictly necessary,
-    #but whatever
-    converted_layers = sequential_container_conversion(
-                config=model_config, name="", verbose=verbose,
-                nonlinear_mxts_mode=nonlinear_mxts_mode,
-                dense_mxts_mode=dense_mxts_mode,
-                conv_mxts_mode=conv_mxts_mode,
-                maxpool_deeplift_mode=maxpool_deeplift_mode,
-                converted_layers=converted_layers,
-                layer_overrides=layer_overrides)
-    converted_layers[-1].build_fwd_pass_vars()
-    return models.SequentialModel(converted_layers)
+    # use variable scope if multiple deeplift models are constructed in a session
+    with tf.variable_scope(None, default_name='deeplift'):
+        converted_layers = []
+        batch_input_shape = model_config[0]['config'][KerasKeys.batch_input_shape]
+        converted_layers.append(
+            layers.core.Input(batch_shape=batch_input_shape, name="input"))
+        #converted_layers is actually mutated to be extended with the
+        #additional layers so the assignment is not strictly necessary,
+        #but whatever
+        converted_layers = sequential_container_conversion(
+                    config=model_config, name="", verbose=verbose,
+                    nonlinear_mxts_mode=nonlinear_mxts_mode,
+                    dense_mxts_mode=dense_mxts_mode,
+                    conv_mxts_mode=conv_mxts_mode,
+                    maxpool_deeplift_mode=maxpool_deeplift_mode,
+                    converted_layers=converted_layers,
+                    layer_overrides=layer_overrides)
+        converted_layers[-1].build_fwd_pass_vars()
+        return models.SequentialModel(converted_layers)
 
 
 def sequential_container_conversion(config,
@@ -819,20 +821,22 @@ def convert_functional_model(
     if (verbose):
         print("nonlinear_mxts_mode is set to: "+str(nonlinear_mxts_mode))
 
-    converted_model_container = functional_container_conversion(
-                            config=model_config,
-                            name="", verbose=verbose,
-                            nonlinear_mxts_mode=nonlinear_mxts_mode,
-                            dense_mxts_mode=dense_mxts_mode,
-                            conv_mxts_mode=conv_mxts_mode,
-                            maxpool_deeplift_mode=maxpool_deeplift_mode,
-                            layer_overrides=layer_overrides,
-                            custom_conversion_funcs=custom_conversion_funcs)
-
-    for output_layer in converted_model_container.output_layers:
-        output_layer.build_fwd_pass_vars()
-
-    return models.GraphModel(
-            name_to_layer=converted_model_container.name_to_deeplift_layer,
-            input_layer_names=converted_model_container.input_layer_names)
+    # use variable scope if multiple deeplift models are constructed in a session
+    with tf.variable_scope(None, default_name='deeplift'):
+        converted_model_container = functional_container_conversion(
+                                config=model_config,
+                                name="", verbose=verbose,
+                                nonlinear_mxts_mode=nonlinear_mxts_mode,
+                                dense_mxts_mode=dense_mxts_mode,
+                                conv_mxts_mode=conv_mxts_mode,
+                                maxpool_deeplift_mode=maxpool_deeplift_mode,
+                                layer_overrides=layer_overrides,
+                                custom_conversion_funcs=custom_conversion_funcs)
+
+        for output_layer in converted_model_container.output_layers:
+            output_layer.build_fwd_pass_vars()
+
+        return models.GraphModel(
+                name_to_layer=converted_model_container.name_to_deeplift_layer,
+                input_layer_names=converted_model_container.input_layer_names)
 

deeplift/layers/convolutional.py

@@ -5,6 +5,7 @@
 from .helper_functions import conv1d_transpose_via_conv2d
 from . import helper_functions as hf
 import tensorflow as tf
+from deeplift.util import to_tf_variable
 
 PoolMode = deeplift.util.enum(max='max', avg='avg')
 PaddingMode = deeplift.util.enum(same='SAME', valid='VALID')
@@ -34,8 +35,8 @@ def __init__(self, kernel, bias, stride, padding, **kwargs):
         super(Conv1D, self).__init__(**kwargs)
         #kernel has dimensions:
         #length x inp_channels x num output channels
-        self.kernel = kernel
-        self.bias = bias
+        self.kernel = to_tf_variable(kernel, name=self.get_name() + "_kernel")
+        self.bias = to_tf_variable(bias, name=self.get_name() + "_bias")
         if (hasattr(stride, '__iter__')):
             assert len(stride)==1
             stride=stride[0]
@@ -54,7 +55,7 @@ def _compute_shape(self, input_shape):
                     1+int((input_shape[1]-self.kernel.shape[0])/self.stride))
             elif (self.padding == PaddingMode.same):
                 shape_to_return.append(
-                    int((input_shape[1]+self.stride-1)/self.stride)) 
+                    int((input_shape[1]+self.stride-1)/self.stride))
             else:
                 raise RuntimeError("Please implement shape inference for"
                                    " padding mode: "+str(self.padding))
@@ -69,7 +70,7 @@ def _build_activation_vars(self, input_act_vars):
 
     def _build_pos_and_neg_contribs(self):
         if (self.conv_mxts_mode == ConvMxtsMode.Linear):
-            inp_diff_ref = self._get_input_diff_from_reference_vars() 
+            inp_diff_ref = self._get_input_diff_from_reference_vars()
             pos_contribs = (self._compute_conv_without_bias(
                              x=inp_diff_ref*hf.gt_mask(inp_diff_ref,0.0),
                              kernel=self.kernel*hf.gt_mask(self.kernel,0.0))
@@ -95,12 +96,12 @@ def _compute_conv_without_bias(self, x, kernel):
                              padding=self.padding)
         return conv_without_bias
 
-    def _get_mxts_increments_for_inputs(self): 
+    def _get_mxts_increments_for_inputs(self):
         pos_mxts = self.get_pos_mxts()
         neg_mxts = self.get_neg_mxts()
-        inp_diff_ref = self._get_input_diff_from_reference_vars() 
+        inp_diff_ref = self._get_input_diff_from_reference_vars()
         output_shape = self._get_input_shape()
-        if (self.conv_mxts_mode == ConvMxtsMode.Linear): 
+        if (self.conv_mxts_mode == ConvMxtsMode.Linear):
             pos_inp_mask = hf.gt_mask(inp_diff_ref,0.0)
             neg_inp_mask = hf.lt_mask(inp_diff_ref,0.0)
             zero_inp_mask = hf.eq_mask(inp_diff_ref,0.0)
@@ -159,8 +160,8 @@ def __init__(self, kernel, bias, strides, padding, data_format, **kwargs):
         super(Conv2D, self).__init__(**kwargs)
         #kernel has dimensions:
         #rows_kern_width x cols_kern_width x inp_channels x num output channels
-        self.kernel = kernel
-        self.bias = bias
+        self.kernel = to_tf_variable(kernel, name=self.get_name() + "_kernel")
+        self.bias = to_tf_variable(bias, name=self.get_name() + "_bias")
         self.strides = strides
         self.padding = padding
         self.data_format = data_format
@@ -184,12 +185,12 @@ def _compute_shape(self, input_shape):
                     zip(input_shape[1:3], self.kernel.shape[:2], self.strides):
                     #overhangs are excluded
                     shape_to_return.append(
-                     1+int((dim_inp_len-dim_kern_width)/dim_stride)) 
+                     1+int((dim_inp_len-dim_kern_width)/dim_stride))
             elif (self.padding == PaddingMode.same):
                 for (dim_inp_len, dim_kern_width, dim_stride) in\
                     zip(input_shape[1:3], self.kernel.shape[:2], self.strides):
                     shape_to_return.append(
-                     int((dim_inp_len+dim_stride-1)/dim_stride)) 
+                     int((dim_inp_len+dim_stride-1)/dim_stride))
             else:
                 raise RuntimeError("Please implement shape inference for"
                                    " border mode: "+str(self.padding))
@@ -216,11 +217,11 @@ def _build_activation_vars(self, input_act_vars):
         if (self.data_format == DataFormat.channels_first):
             to_return = tf.transpose(a=to_return,
                                      perm=[0,3,1,2])
-        return to_return 
+        return to_return
 
     def _build_pos_and_neg_contribs(self):
         if (self.conv_mxts_mode == ConvMxtsMode.Linear):
-            inp_diff_ref = self._get_input_diff_from_reference_vars() 
+            inp_diff_ref = self._get_input_diff_from_reference_vars()
             if (self.data_format == DataFormat.channels_first):
                 inp_diff_ref = tf.transpose(a=inp_diff_ref,
                                             perm=[0,2,3,1])
@@ -255,10 +256,10 @@ def _compute_conv_without_bias(self, x, kernel):
                              padding=self.padding)
         return conv_without_bias
 
-    def _get_mxts_increments_for_inputs(self): 
+    def _get_mxts_increments_for_inputs(self):
         pos_mxts = self.get_pos_mxts()
         neg_mxts = self.get_neg_mxts()
-        inp_diff_ref = self._get_input_diff_from_reference_vars() 
+        inp_diff_ref = self._get_input_diff_from_reference_vars()
         inp_act_vars = self.inputs.get_activation_vars()
         strides_to_supply = [1]+list(self.strides)+[1]
 
@@ -270,11 +271,11 @@ def _get_mxts_increments_for_inputs(self):
 
         output_shape = tf.shape(inp_act_vars)
 
-        if (self.conv_mxts_mode == ConvMxtsMode.Linear): 
+        if (self.conv_mxts_mode == ConvMxtsMode.Linear):
             pos_inp_mask = hf.gt_mask(inp_diff_ref,0.0)
             neg_inp_mask = hf.lt_mask(inp_diff_ref,0.0)
             zero_inp_mask = hf.eq_mask(inp_diff_ref, 0.0)
-            
+
             inp_mxts_increments = pos_inp_mask*(
                         tf.nn.conv2d_transpose(
                             value=pos_mxts,
@@ -319,7 +320,7 @@ def _get_mxts_increments_for_inputs(self):
 
         if (self.data_format == DataFormat.channels_first):
             pos_mxts_increments = tf.transpose(a=pos_mxts_increments,
-                                               perm=(0,3,1,2)) 
+                                               perm=(0,3,1,2))
             neg_mxts_increments = tf.transpose(a=neg_mxts_increments,
                                                perm=(0,3,1,2))
 

deeplift/layers/core.py

@@ -7,7 +7,8 @@
 from collections import namedtuple
 from collections import OrderedDict
 from collections import defaultdict
-import deeplift.util  
+import deeplift.util
+from deeplift.util import to_tf_variable
 from .helper_functions import (
  pseudocount_near_zero, add_val_to_col)
 from . import helper_functions as hf
@@ -520,8 +521,11 @@ class Dense(SingleInputMixin, OneDimOutputMixin, Node):
 
     def __init__(self, kernel, bias, dense_mxts_mode, **kwargs):
         super(Dense, self).__init__(**kwargs)
-        self.kernel = np.array(kernel).astype("float32")
-        self.bias = np.array(bias).astype("float32")
+
+        self.kernel = to_tf_variable(np.array(kernel).astype("float32"),
+                                     name=self.get_name() + "_kernel")
+        self.bias = to_tf_variable(np.array(bias).astype("float32"),
+                                   name=self.get_name() + "_bias")
         self.dense_mxts_mode = dense_mxts_mode
 
     def _compute_shape(self, input_shape):
@@ -560,19 +564,22 @@ def _get_mxts_increments_for_inputs(self):
             pos_inp_mask = hf.gt_mask(inp_diff_ref,0.0)
             neg_inp_mask = hf.lt_mask(inp_diff_ref,0.0)
             zero_inp_mask = hf.eq_mask(inp_diff_ref,0.0)
+
+            kernel_T = tf.transpose(self.kernel)
+
             inp_mxts_increments = pos_inp_mask*(
                 tf.matmul(self.get_pos_mxts(),
-                          self.kernel.T*(hf.gt_mask(self.kernel.T, 0.0)))
+                          kernel_T*(hf.gt_mask(kernel_T, 0.0)))
                 + tf.matmul(self.get_neg_mxts(),
-                            self.kernel.T*(hf.lt_mask(self.kernel.T, 0.0)))) 
+                            kernel_T*(hf.lt_mask(kernel_T, 0.0))))
             inp_mxts_increments += neg_inp_mask*(
                 tf.matmul(self.get_pos_mxts(),
-                          self.kernel.T*(hf.lt_mask(self.kernel.T, 0.0)))
+                          kernel_T*(hf.lt_mask(kernel_T, 0.0)))
                 + tf.matmul(self.get_neg_mxts(),
-                            self.kernel.T*(hf.gt_mask(self.kernel.T, 0.0)))) 
+                            kernel_T*(hf.gt_mask(kernel_T, 0.0))))
             inp_mxts_increments += zero_inp_mask*(
                 tf.matmul(0.5*(self.get_pos_mxts()
-                               +self.get_neg_mxts()), self.kernel.T))
+                               +self.get_neg_mxts()), kernel_T))
             #pos_mxts and neg_mxts in the input get the same multiplier
             #because the breakdown between pos and neg wasn't used to
             #compute pos_contribs and neg_contribs in the forward pass

deeplift/layers/normalization.py

@@ -7,7 +7,7 @@
 from collections import namedtuple
 from collections import OrderedDict
 from collections import defaultdict
-import deeplift.util  
+from deeplift.util import to_tf_variable
 from .helper_functions import (
  pseudocount_near_zero, add_val_to_col)
 from . import helper_functions as hf
@@ -33,12 +33,12 @@ def __init__(self, gamma, beta, axis,
         #implementation, seems to support these only being one dimensional
         assert len(mean.shape)==1
         assert len(var.shape)==1
-        self.gamma = gamma
-        self.beta = beta
+        self.gamma = to_tf_variable(gamma, self.get_name() + '_gamma')
+        self.beta = to_tf_variable(beta, self.get_name() + '_beta')
         self.axis = axis
-        self.mean = mean
-        self.var = var
-        self.epsilon = epsilon
+        self.mean = to_tf_variable(mean, self.get_name() + '_mean')
+        self.var = to_tf_variable(var, self.get_name() + '_var')
+        self.epsilon = tf.constant(epsilon)
 
     def _compute_shape(self, input_shape):
         return input_shape

deeplift/util.py

@@ -426,3 +426,10 @@ def in_place_shuffle(arr):
         arr[chosen_index] = arr[i]
         arr[i] = val_at_index
     return arr
+
+
+def to_tf_variable(np_array, name):
+    if type(np_array) == list:
+        np_array = np.array(np_array)
+    return tf.get_variable(name, dtype=np_array.dtype,
+                           initializer=np_array, trainable=False)