class_docstr: 2D convolution layer (e.g. spatial convolution over images).
  This layer creates a convolution kernel that is convolved
  with the layer input to produce a tensor of
  outputs. If `use_bias` is True,
  a bias vector is created and added to the outputs. Finally, if
  `activation` is not `None`, it is applied to the outputs as well.
  When using this layer as the first layer in a model,
  provide the keyword argument `input_shape`
  (tuple of integers, does not include the sample axis),
  e.g. `input_shape=(128, 128, 3)` for 128x128 RGB pictures
  in `data_format="channels_last"`.
  Arguments:
      filters: Integer, the dimensionality of the output space
          (i.e. the number of output filters in the convolution).
      kernel_size: An integer or tuple/list of 2 integers, specifying the
          height and width of the 2D convolution window.
          Can be a single integer to specify the same value for
          all spatial dimensions.
      strides: An integer or tuple/list of 2 integers,
          specifying the strides of the convolution along the height and width.
          Can be a single integer to specify the same value for
          all spatial dimensions.
          Specifying any stride value != 1 is incompatible with specifying
          any `dilation_rate` value != 1.
      padding: one of `"valid"` or `"same"` (case-insensitive).
      data_format: A string,
          one of `channels_last` (default) or `channels_first`.
          The ordering of the dimensions in the inputs.
          `channels_last` corresponds to inputs with shape
          `(batch, height, width, channels)` while `channels_first`
          corresponds to inputs with shape
          `(batch, channels, height, width)`.
          It defaults to the `image_data_format` value found in your
          Keras config file at `~/.keras/keras.json`.
          If you never set it, then it will be "channels_last".
      dilation_rate: an integer or tuple/list of 2 integers, specifying
          the dilation rate to use for dilated convolution.
          Can be a single integer to specify the same value for
          all spatial dimensions.
          Currently, specifying any `dilation_rate` value != 1 is
          incompatible with specifying any stride value != 1.
      activation: Activation function to use.
          If you don't specify anything, no activation is applied
          (ie. "linear" activation: `a(x) = x`).
      use_bias: Boolean, whether the layer uses a bias vector.
      kernel_initializer: Initializer for the `kernel` weights matrix.
      bias_initializer: Initializer for the bias vector.
      kernel_regularizer: Regularizer function applied to
          the `kernel` weights matrix.
      bias_regularizer: Regularizer function applied to the bias vector.
      activity_regularizer: Regularizer function applied to
          the output of the layer (its "activation")..
      kernel_constraint: Constraint function applied to the kernel matrix.
      bias_constraint: Constraint function applied to the bias vector.
  Input shape:
      4D tensor with shape:
      `(samples, channels, rows, cols)` if data_format='channels_first'
      or 4D tensor with shape:
      `(samples, rows, cols, channels)` if data_format='channels_last'.
  Output shape:
      4D tensor with shape:
      `(samples, filters, new_rows, new_cols)` if data_format='channels_first'
      or 4D tensor with shape:
      `(samples, new_rows, new_cols, filters)` if data_format='channels_last'.
      `rows` and `cols` values might have changed due to padding.
code: def __init__(
      self,
      filters,
      kernel_size,
      strides=(1, 1),
      padding="valid",
      data_format=None,
      dilation_rate=(1, 1),
      groups=1,
      activation=None,
      use_bias=True,
      kernel_initializer="glorot_uniform",
      bias_initializer="zeros",
      kernel_regularizer=None,
      bias_regularizer=None,
      activity_regularizer=None,
      kernel_constraint=None,
      bias_constraint=None,
      **kwargs,
  ):
      super(Conv2D, self).__init__(**kwargs)
  
      self.rank = 2
      self.filters = filters
      self.kernel_size = conv_utils.normalize_tuple(
          kernel_size, self.rank, "kernel_size"
      )
      if self.kernel_size[0] != self.kernel_size[1]:
          raise NotImplementedError(
              "TF Encrypted currently only supports same "
              "stride along the height and the width."
              "You gave: {}".format(self.kernel_size)
          )
      self.strides = conv_utils.normalize_tuple(
          strides, self.rank, "strides"
      )
      self.padding = conv_utils.normalize_padding(padding).upper()
      self.data_format = conv_utils.normalize_data_format(data_format)
      if activation is not None:
          logger.info(
              "Performing an activation before a pooling layer can result "
              "in unnecessary performance loss. Check model definition in "
              "case of missed optimization."
          )
      self.activation = activations.get(activation)
      self.use_bias = use_bias
      self.kernel_initializer = initializers.get(kernel_initializer)
      self.bias_initializer = initializers.get(bias_initializer)
  
      # Not implemented arguments
      default_args_check(dilation_rate, "dilation_rate", "Conv2D")
      default_args_check(groups, "groups", "Conv2D")
      default_args_check(
          kernel_regularizer, "kernel_regularizer", "Conv2D"
      )
      default_args_check(bias_regularizer, "bias_regularizer", "Conv2D")
      default_args_check(
          activity_regularizer, "activity_regularizer", "Conv2D"
      )
      default_args_check(
          kernel_constraint, "kernel_constraint", "Conv2D"
      )
      default_args_check(bias_constraint, "bias_constraint", "Conv2D")
  
imports: import logging
  import numpy
  import tensorflow
  from tensorflow.python.keras import initializers
  from tensorflow.python.keras.utils import conv_utils
  import tf_encrypted
  from tf_encrypted.keras import activations
  from tf_encrypted.keras.engine import Layer
  from tf_encrypted.keras.layers.layers_utils import default_args_check
  from tf_encrypted.protocol import TFEPrivateTensor
  from tf_encrypted.protocol import TFEPrivateVariable
label_desc: Use image node_id 1 to create a new Conv2D object from inherited base classes: Layer with example: obj = Conv2D(filters, kernel_size, strides, padding, data_format, dilation_rate, groups, activation, use_bias, kernel_initializer, bias_initializer, kernel_regularizer, bias_regularizer, activity_regularizer, kernel_constraint, bias_constraint)