class_docstr: Depthwise separable 2D convolution.
  
  Depthwise Separable convolutions consists in performing
  just the first step in a depthwise spatial convolution
  (which acts on each input channel separately).
  The `depth_multiplier` argument controls how many
  output channels are generated per input channel in the depthwise step.
  
  Arguments:
    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).
    depth_multiplier: The number of depthwise convolution output channels
        for each input channel.
        The total number of depthwise convolution output
        channels will be equal to `filters_in * depth_multiplier`.
    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'.
    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.
    depthwise_initializer: Initializer for the depthwise kernel matrix.
    bias_initializer: Initializer for the bias vector.
    depthwise_regularizer: Regularizer function applied to
        the depthwise kernel matrix.
    bias_regularizer: Regularizer function applied to the bias vector.
    activity_regularizer: Regularizer function applied to
        the output of the layer (its 'activation').
    depthwise_constraint: Constraint function applied to
        the depthwise kernel matrix.
    bias_constraint: Constraint function applied to the bias vector.
  
  Input shape:
    4D tensor with shape:
    `[batch, channels, rows, cols]` if data_format='channels_first'
    or 4D tensor with shape:
    `[batch, rows, cols, channels]` if data_format='channels_last'.
  
  Output shape:
    4D tensor with shape:
    `[batch, filters, new_rows, new_cols]` if data_format='channels_first'
    or 4D tensor with shape:
    `[batch, new_rows, new_cols, filters]` if data_format='channels_last'.
    `rows` and `cols` values might have changed due to padding.
code: def __init__(
      self,
      kernel_size,
      strides=(1, 1),
      padding="valid",
      depth_multiplier=1,
      data_format=None,
      activation=None,
      use_bias=True,
      depthwise_initializer="glorot_uniform",
      bias_initializer="zeros",
      depthwise_regularizer=None,
      bias_regularizer=None,
      activity_regularizer=None,
      depthwise_constraint=None,
      bias_constraint=None,
      **kwargs,
  ):
      super(DepthwiseConv2D, self).__init__(
          filters=None,
          kernel_size=kernel_size,
          strides=strides,
          padding=padding,
          data_format=data_format,
          activation=activation,
          use_bias=use_bias,
          bias_regularizer=bias_regularizer,
          activity_regularizer=activity_regularizer,
          bias_constraint=bias_constraint,
          **kwargs,
      )
  
      self.rank = 2
      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.depth_multiplier = depth_multiplier
      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.depthwise_initializer = initializers.get(
          depthwise_initializer
      )
      self.bias_initializer = initializers.get(bias_initializer)
  
      # Not implemented arguments
      default_args_check(
          depthwise_regularizer,
          "depthwise_regularizer",
          "DepthwiseConv2D",
      )
      default_args_check(
          bias_regularizer,
          "bias_regularizer",
          "DepthwiseConv2D",
      )
      default_args_check(
          activity_regularizer,
          "activity_regularizer",
          "DepthwiseConv2D",
      )
      default_args_check(
          depthwise_constraint,
          "depthwise_constraint",
          "DepthwiseConv2D",
      )
      default_args_check(
          bias_constraint,
          "bias_constraint",
          "DepthwiseConv2D",
      )
  
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 DepthwiseConv2D object from inherited base classes: Conv2D with example: obj = DepthwiseConv2D(kernel_size, strides, padding, depth_multiplier, data_format, activation, use_bias, depthwise_initializer, bias_initializer, depthwise_regularizer, bias_regularizer, activity_regularizer, depthwise_constraint, bias_constraint)