code: def _depthwise_conv_block(
      inputs,
      pointwise_conv_filters,
      alpha,
      depth_multiplier=1,
      strides=(1, 1),
      block_id=1,
  ):
      """Adds a depthwise convolution block.
  
      A depthwise convolution block consists of a depthwise conv,
      batch normalization, relu6, pointwise convolution,
      batch normalization and relu6 activation.
  
      Args:
          inputs: Input tensor of shape `(rows, cols, channels)` (with
              `channels_last` data format) or (channels, rows, cols) (with
              `channels_first` data format).
          pointwise_conv_filters: Integer, the dimensionality of the output space
              (i.e. the number of output filters in the pointwise convolution).
          alpha: controls the width of the network. - If `alpha` < 1.0,
              proportionally decreases the number of filters in each layer.
              - If `alpha` > 1.0, proportionally increases the number of filters
                  in each layer.
              - If `alpha` = 1, default number of filters from the paper are
                  used at each layer.
          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`.
          strides: An integer or tuple/list of 2 integers, specifying the strides
              of the convolution along the width and height.
              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.
          block_id: Integer, a unique identification designating the block number.
              # 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 stride.
  
      Returns:
          Output tensor of block.
      """
      channel_axis = (
          1 if backend.image_data_format() == "channels_first" else -1
      )
      pointwise_conv_filters = int(pointwise_conv_filters * alpha)
  
      if strides == (1, 1):
          x = inputs
      else:
          x = layers.ZeroPadding2D(
              ((0, 1), (0, 1)), name="conv_pad_%d" % block_id
          )(inputs)
      x = layers.DepthwiseConv2D(
          (3, 3),
          padding="same" if strides == (1, 1) else "valid",
          depth_multiplier=depth_multiplier,
          strides=strides,
          use_bias=False,
          name="conv_dw_%d" % block_id,
      )(x)
      x = layers.BatchNormalization(
          axis=channel_axis, name="conv_dw_%d_bn" % block_id
      )(x)
      x = layers.ReLU(6.0, name="conv_dw_%d_relu" % block_id)(x)
  
      x = layers.Conv2D(
          pointwise_conv_filters,
          (1, 1),
          padding="same",
          use_bias=False,
          strides=(1, 1),
          name="conv_pw_%d" % block_id,
      )(x)
      x = layers.BatchNormalization(
          axis=channel_axis, name="conv_pw_%d_bn" % block_id
      )(x)
      return layers.ReLU(6.0, name="conv_pw_%d_relu" % block_id)(x)
  
file_path: keras/keras/applications/mobilenet.py
imports: import warnings
  from keras import backend
  from keras import layers
  from keras.api_export import keras_export
  from keras.applications import imagenet_utils
  from keras.models import Functional
  from keras.ops import operation_utils
  from keras.utils import file_utils
label_desc: Use image node_id 3 for calling a global function with example usage: _depthwise_conv_block(inputs, pointwise_conv_filters, alpha, depth_multiplier, strides, block_id) and returns: layers