                         **kwargs)(var_x)
          var_x = LeakyReLU(alpha=0.2)(var_x)
          if self.use_reflect_padding:
              var_x = ReflectionPadding2D(stride=1, kernel_size=kernel_size)(var_x)
              padding = 'valid'
          temp = kwargs["kernel_initializer"]
          kwargs["kernel_initializer"] = VarianceScaling(scale=0.2,
                                                         mode='fan_in',
                                                         distribution='uniform')
          var_x = Conv2D(filters,
                         kernel_size=kernel_size,
                         padding=padding,
                         **kwargs)(var_x)
          kwargs["kernel_initializer"] = temp
          var_x = Add()([var_x, inp])
          var_x = LeakyReLU(alpha=0.2)(var_x)
          return var_x
  
      # <<< Unbalanced Model Blocks >>> #
 
</s> remove             padding = 'valid'
        var_x = Conv2D(filters,
                       kernel_size=kernel_size,
                       padding=padding,
                       **kwargs)(var_x)
 </s> add             padding = "valid"
        var_x = self.conv2d(inp, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            **kwargs) </s> remove             padding = 'valid'
        temp = kwargs["kernel_initializer"]
 </s> add             padding = "valid"
        kwargs = self.update_kwargs(kwargs) </s> remove             kwargs["kernel_initializer"] = ICNR(initializer=kwargs["kernel_initializer"])
        var_x = Conv2D(filters * 4,
                       kernel_size=kernel_size,
                       padding=padding,
                       **kwargs)(inp)
        kwargs["kernel_initializer"] = temp
 </s> add             original_init = self.switch_kernel_initializer(
                kwargs,
                ICNR(initializer=kwargs["kernel_initializer"]))
        var_x = self.conv2d(inp, filters * 4,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        if self.use_icnr_init:
            self.switch_kernel_initializer(kwargs, original_init) </s> remove                                 padding='same',
 </s> add                                 padding="same", </s> remove             padding = 'valid'
        var_x = Conv2D(filters,
                       kernel_size=kernel_size,
                       strides=strides,
                       padding=padding,
                       **kwargs)(inp)
 </s> add             padding = "valid"
        var_x = self.conv2d(inp, filters,
                            kernel_size=kernel_size,
                            strides=strides,
                            padding=padding,
                            **kwargs)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
                         **kwargs)(var_x)
          var_x = LeakyReLU(alpha=0.2)(var_x)
          if self.use_reflect_padding:
              var_x = ReflectionPadding2D(stride=1, kernel_size=kernel_size)(var_x)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
            padding = "valid"
        original_init = self.switch_kernel_initializer(kwargs, VarianceScaling(
            scale=0.2,
            mode="fan_in",
            distribution="uniform"))
        var_x = self.conv2d(var_x, filters,
                            kernel_size=kernel_size,
                            padding=padding,
                            force_initializer=True,
                            **kwargs)
        self.switch_kernel_initializer(kwargs, original_init)
          var_x = Add()([var_x, inp])
          var_x = LeakyReLU(alpha=0.2)(var_x)
          return var_x
  
      # <<< Unbalanced Model Blocks >>> #
keep keep keep keep replace replace replace replace replace replace replace replace replace replace keep keep keep keep keep
 Add Convolutional Aware Initialization (#795)

* Training: Add Convolutional Aware Initialization config option

* Centralize Conv2D layer for handling initializer

* Add 'is-output' to NNMeta to indicate that network is an output to the Model 
lib/model/nn_blocks.py