class_docstr: Layer to be used as an entry point into a Network (a graph of layers).
  It can either wrap an existing tensor (pass an `input_tensor` argument)
  or create its a placeholder tensor (pass arguments `input_shape`, and
  optionally, `dtype`).
  It is generally recommend to use the functional layer API via `Input`,
  (which creates an `InputLayer`) without directly using `InputLayer`.
  Arguments:
      input_shape: Shape tuple (not including the batch axis), or `TensorShape`
        instance (not including the batch axis).
      batch_size: Optional input batch size (integer or None).
      dtype: Datatype of the input.
      input_tensor: Optional tensor to use as layer input
          instead of creating a placeholder.
      sparse: Boolean, whether the placeholder created
          is meant to be sparse.
      name: Name of the layer (string).
code: def __init__(
      self,
      input_shape=None,
      batch_size=None,
      dtype=None,
      input_tensor=None,
      sparse=False,
      name=None,
      **kwargs,
  ):
      if "batch_input_shape" in kwargs:
          batch_input_shape = kwargs.pop("batch_input_shape")
          if input_shape and batch_input_shape:
              raise ValueError(
                  "Only provide the input_shape OR "
                  "batch_input_shape argument to "
                  "InputLayer, not both at the same time."
              )
          batch_size = batch_input_shape[0]
          input_shape = batch_input_shape[1:]
      if kwargs:
          raise ValueError(
              "Unrecognized keyword arguments:", kwargs.keys()
          )
  
      if not name:
          prefix = "input"
          name = prefix + "_" + str(backend.get_uid(prefix))
  
      if batch_size is None:
          raise NotImplementedError()
      if input_tensor is not None:
          raise NotImplementedError()
      if dtype is not None:
          raise NotImplementedError()
      if sparse:
          raise NotImplementedError()
  
      super(InputLayer, self).__init__()
      self.built = True
      self.batch_size = batch_size
  
      if isinstance(input_shape, tensor_shape.TensorShape):
          input_shape = tuple(input_shape.as_list())
      elif isinstance(input_shape, int):
          input_shape = (input_shape,)
  
      if input_shape is not None:
          self._batch_input_shape = (batch_size,) + tuple(input_shape)
      else:
          raise ValueError(
              "Input shape must be defined for the first layer."
          )
  
      # Create a graph placeholder to call the layer on.
      self.input = tfe.define_private_variable(
          np.zeros(self._batch_input_shape)
      )
  
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 to create a new InputLayer object from inherited base classes: Layer with example: obj = InputLayer(input_shape, batch_size, dtype, input_tensor, sparse, name)