code: def highway_conv_2d(
      incoming,
      nb_filter,
      filter_size,
      strides=1,
      padding="same",
      activation="linear",
      weights_init="uniform_scaling",
      bias_init="zeros",
      regularizer=None,
      weight_decay=0.001,
      trainable=True,
      restore=True,
      reuse=False,
      scope=None,
      name="HighwayConv2D",
  ):
      """Highway Convolution 2D.
  
      Input:
          4-D Tensor [batch, height, width, in_channels].
  
      Output:
          4-D Tensor [batch, new height, new width, nb_filter].
  
      Arguments:
          incoming: `Tensor`. Incoming 4-D Tensor.
          nb_filter: `int`. The number of convolutional filters.
          filter_size: `int` or `list of int`. Size of filters.
          strides: `int` or `list of int`. Strides of conv operation.
              Default: [1 1 1 1].
          padding: `str` from `"same", "valid"`. Padding algo to use.
              Default: 'same'.
          activation: `str` (name) or `function` (returning a `Tensor`).
              Activation applied to this layer (see tflearn.activations).
              Default: 'linear'.
          weights_init: `str` (name) or `Tensor`. Weights initialization.
              (see tflearn.initializations) Default: 'truncated_normal'.
          bias_init: `str` (name) or `Tensor`. Bias initialization.
              (see tflearn.initializations) Default: 'zeros'.
          regularizer: `str` (name) or `Tensor`. Add a regularizer to this
              layer weights (see tflearn.regularizers). Default: None.
          weight_decay: `float`. Regularizer decay parameter. Default: 0.001.
          trainable: `bool`. If True, weights will be trainable.
          restore: `bool`. If True, this layer weights will be restored when
              loading a model
          reuse: `bool`. If True and 'scope' is provided, this layer variables
              will be reused (shared).
          scope: `str`. Define this layer scope (optional). A scope can be
              used to share variables between layers. Note that scope will
              override name.
          name: A name for this layer (optional). Default: 'Conv2D'.
  
      Attributes:
          scope: `Scope`. This layer scope.
          W: `Variable`. Variable representing filter weights.
          W_T: `Variable`. Variable representing gate weights.
          b: `Variable`. Variable representing biases.
          b_T: `Variable`. Variable representing gate biases.
  
      """
      input_shape = utils.get_incoming_shape(incoming)
      assert (
          len(input_shape) == 4
      ), "Incoming Tensor shape must be 4-D, not %d-D" % len(
          input_shape
      )
      filter_size = utils.autoformat_filter_conv2d(
          filter_size, input_shape[-1], nb_filter
      )
      strides = utils.autoformat_kernel_2d(strides)
      padding = utils.autoformat_padding(padding)
  
      with tf.variable_scope(
          scope, default_name=name, values=[incoming], reuse=reuse
      ) as scope:
          name = scope.name
  
          W_init = weights_init
          if isinstance(weights_init, str):
              W_init = initializations.get(weights_init)()
          W_regul = None
          if regularizer is not None:
              W_regul = lambda x: regularizers.get(regularizer)(
                  x, weight_decay
              )
          W = vs.variable(
              "W",
              shape=filter_size,
              regularizer=W_regul,
              initializer=W_init,
              trainable=trainable,
              restore=restore,
          )
          # Track per layer variables
          tf.add_to_collection(
              tf.GraphKeys.LAYER_VARIABLES + "/" + name, W
          )
  
          bias_init = initializations.get(bias_init)()
          b = vs.variable(
              "b",
              shape=nb_filter,
              initializer=bias_init,
              trainable=trainable,
              restore=restore,
          )
          # Track per layer variables
          tf.add_to_collection(
              tf.GraphKeys.LAYER_VARIABLES + "/" + name, b
          )
  
          # Weight and bias for the transform gate
          W_T = vs.variable(
              "W_T",
              shape=nb_filter,
              regularizer=None,
              initializer=W_init,
              trainable=trainable,
              restore=restore,
          )
          tf.add_to_collection(
              tf.GraphKeys.LAYER_VARIABLES + "/" + name, W_T
          )
  
          b_T = vs.variable(
              "b_T",
              shape=nb_filter,
              initializer=tf.constant_initializer(-3),
              trainable=trainable,
              restore=restore,
          )
          tf.add_to_collection(
              tf.GraphKeys.LAYER_VARIABLES + "/" + name, b_T
          )
  
          if isinstance(activation, str):
              activation = activations.get(activation)
          elif hasattr(activation, "__call__"):
              activation = activation
          else:
              raise ValueError("Invalid Activation.")
  
          # Shared convolution for gating
          convolved = tf.nn.conv2d(incoming, W, strides, padding)
          H = activation(convolved + b)
          T = tf.sigmoid(tf.multiply(convolved, W_T) + b_T)
          C = tf.subtract(1.0, T)
          inference = tf.add(
              tf.multiply(H, T), tf.multiply(convolved, C)
          )
  
          # Track activations.
          tf.add_to_collection(tf.GraphKeys.ACTIVATIONS, inference)
  
      # Add attributes to Tensor to easy access weights.
      inference.scope = scope
      inference.W = W
      inference.W_T = W_T
      inference.b = b
      inference.b_T = b_T
  
      # Track output tensor.
      tf.add_to_collection(
          tf.GraphKeys.LAYER_TENSOR + "/" + name, inference
      )
  
      return inference
  
imports: from __future__ import division, print_function, absolute_import
  import tensorflow.compat.v1
  import numpy
  from math import ceil
  import tflearn
  from ..None import variables
  from ..None import activations
  from ..None import initializations
  from ..None import regularizers
  from ..None import utils
  from ..layers.normalization import batch_normalization
label_desc: Use image node_id 23 for calling a global function with example usage: highway_conv_2d(incoming, nb_filter, filter_size, strides, padding, activation, weights_init, bias_init, regularizer, weight_decay, trainable, restore, reuse, scope, name) and returns: inference