code: def _linear(
      args,
      output_size,
      bias,
      bias_initializer=None,
      kernel_initializer=None,
  ):
      """Linear map: sum_i(args[i] * W[i]), where W[i] is a variable.
  
      Args:
        args: a 2D Tensor or a list of 2D, batch, n, Tensors.
        output_size: int, second dimension of W[i].
        bias: boolean, whether to add a bias term or not.
        bias_initializer: starting value to initialize the bias
          (default is all zeros).
        kernel_initializer: starting value to initialize the weight.
  
      Returns:
        A 2D Tensor with shape `[batch, output_size]` equal to
        sum_i(args[i] * W[i]), where W[i]s are newly created matrices.
  
      Raises:
        ValueError: if some of the arguments has unspecified or wrong shape.
      """
      if args is None or (nest.is_sequence(args) and not args):
          raise ValueError("`args` must be specified")
      if not nest.is_sequence(args):
          args = [args]
  
      # Calculate the total size of arguments on dimension 1.
      total_arg_size = 0
      shapes = [a.get_shape() for a in args]
      for shape in shapes:
          if shape.ndims != 2:
              raise ValueError(
                  "linear is expecting 2D arguments: %s" % shapes
              )
          if shape.dims[1].value is None:
              raise ValueError(
                  "linear expects shape[1] to be provided for shape %s, "
                  "but saw %s" % (shape, shape[1])
              )
          else:
              total_arg_size += shape.dims[1].value
  
      dtype = [a.dtype for a in args][0]
  
      # Now the computation.
      scope = vs.get_variable_scope()
      with vs.variable_scope(scope) as outer_scope:
          weights = vs.get_variable(
              _WEIGHTS_VARIABLE_NAME,
              [total_arg_size, output_size],
              dtype=dtype,
              initializer=kernel_initializer,
          )
          if len(args) == 1:
              res = math_ops.matmul(args[0], weights)
          else:
              res = math_ops.matmul(array_ops.concat(args, 1), weights)
          if not bias:
              return res
          with vs.variable_scope(outer_scope) as inner_scope:
              inner_scope.set_partitioner(None)
              if bias_initializer is None:
                  bias_initializer = init_ops.constant_initializer(
                      0.0, dtype=dtype
                  )
              biases = vs.get_variable(
                  _BIAS_VARIABLE_NAME,
                  [output_size],
                  dtype=dtype,
                  initializer=bias_initializer,
              )
          return nn_ops.bias_add(res, biases)
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import math
  from tensorflow.python.framework import constant_op
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import embedding_ops
  from tensorflow.python.ops import init_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import nn_ops
  from tensorflow.python.ops import rnn_cell_impl
  from tensorflow.python.ops import variable_scope
  from tensorflow.python.platform import tf_logging
  from tensorflow.python.util import nest
label_desc: Use image node_id 1 for calling a global function with example usage: _linear(args, output_size, bias, bias_initializer, kernel_initializer) and returns: nn_ops, res