code: def Input(  # pylint: disable=invalid-name
      shape=None,
      batch_size=None,
      name=None,
      dtype=None,
      sparse=False,
      tensor=None,
      **kwargs,
  ):
      """`Input()` is used to instantiate a Keras tensor.
      A Keras tensor is a tensor object from the underlying backend
      (TF Encrypted), which we augment with certain
      attributes that allow us to build a Keras model.
  
      Arguments:
          shape: A shape tuple (integers), not including the batch size.
              For instance, `shape=(32,)` indicates that the expected input
              will be batches of 32-dimensional vectors.
          batch_size: optional static batch size (integer).
          name: An optional name string for the layer.
              Should be unique in a model (do not reuse the same name twice).
              It will be autogenerated if it isn't provided.
          dtype: The data type expected by the input, as a string
              (`float32`, `float64`, `int32`...)
          sparse: A boolean specifying whether the placeholder
              to be created is sparse.
          tensor: Optional existing tensor to wrap into the `Input` layer.
              If set, the layer will not create a placeholder tensor.
          **kwargs: deprecated arguments support.
  
      Returns:
        A `tensor`.
  
      Example:
      ```python
      # this is a logistic regression in Keras
      x = Input(shape=(32,))
      y = Dense(16, activation='softmax')(x)
      model = Model(x, y)
      ```
      Note that even if eager execution is enabled,
      `Input` produces a symbolic tensor (i.e. a placeholder).
      This symbolic tensor can be used with other
      TensorFlow ops, as such:
      ```python
      x = Input(shape=(32,))
      y = tf.square(x)
      ```
  
      Raises:
        ValueError: in case of invalid arguments.
      """
      batch_shape = None
      if "batch_shape" in kwargs:
          batch_shape = kwargs.pop("batch_shape")
          if shape and batch_shape:
              raise ValueError(
                  "Only provide the shape OR "
                  "batch_shape argument to "
                  "Input, not both at the same time."
              )
          batch_size = batch_shape[0]
          shape = batch_shape[1:]
      if kwargs:
          raise ValueError(
              "Unrecognized keyword arguments:", kwargs.keys()
          )
  
      if shape is None and tensor is None:
          raise ValueError(
              "Please provide to Input either a `shape`"
              " or a `tensor` argument. Note that "
              "`shape` does not include the batch "
              "dimension."
          )
  
      if sparse:
          raise NotImplementedError()
      if dtype is not None:
          raise NotImplementedError()
      if tensor is not None:
          raise NotImplementedError()
  
      if batch_shape:
          input_layer = InputLayer(
              batch_input_shape=batch_shape,
              name=name,
              dtype=dtype,
              sparse=sparse,
              input_tensor=tensor,
          )
      else:
          input_layer = InputLayer(
              input_shape=shape,
              batch_size=batch_size,
              name=name,
              dtype=dtype,
              sparse=sparse,
              input_tensor=tensor,
          )
  
      # Return tensor including `_keras_history`.
      # Note that in this case train_output and test_output are the same pointer.
      return input_layer.input
  
file_path: tf-encrypted/tf_encrypted/keras/engine/input_layer.py
imports: import numpy
  from tensorflow.keras import backend
  from tensorflow.python.framework import tensor_shape
  import tf_encrypted
  from tf_encrypted.keras.engine.base_layer import Layer
label_desc: Use image node_id 1 for calling a global function with example usage: Input(shape, batch_size, name, dtype, sparse, tensor) and returns: input_layer