class_docstr: Layer for Deep & Cross Network to learn explicit feature interactions.
  
  A layer that applies feature crossing in learning certain explicit
  bounded-degree feature interactions more efficiently. The `call` method
  accepts `inputs` as a tuple of size 2 tensors. The first input `x0` should be
  the input to the first `PolynomialCrossing` layer in the stack, or the input
  to the network (usually after the embedding layer), the second input `xi`
  is the output of the previous `PolynomialCrossing` layer in the stack, i.e.,
  the i-th `PolynomialCrossing` layer.
  
  The output is `x[i+1] = x0 .* (W * x[i] + diag_scale * x[i]) + bias + x[i]`, where .* designates elementwise
  multiplication, W could be a full rank matrix, or a low rank matrix `U*V` to reduce the computational cost,
  and diag_scale increases the diagonal of W to improve training stability (especially for the low rank case).
  
  See [Deep & Cross Network for Ad Click Predictions](https://arxiv.org/pdf/1708.05123.pdf).
  
  Example:
  
  >>> input = np.random.randint(10, size=(10, 5))
  >>> x0 = tf.keras.layers.Embedding(input_dim=10, output_dim=3)(input)
  >>> x1 = PolynomialCrossing(projection_dim=None)((x0, x0))
  >>> x2 = PolynomialCrossing(projection_dim=None)((x0, x1))
  >>> logits = tf.keras.layers.Dense(units=10)(x2)
  >>> model = tf.keras.Model(logits)
  
  Args:
      projection_dim: project dimension to reduce the computational cost.
        Default is `None` such that a full (`input_dim` by `input_dim`)
        matrix W is used. If enabled, a low-rank matrix W = U*V will be used,
        where U is of size `input_dim` by `projection_dim` and V is of size
        `projection_dim` by `input_dim`. `projection_dim` need to be smaller
        than `input_dim`/2 to improve the model efficiency.
      diag_scale: a non-negative float used to increase the diagonal of the
         kernel W by `diag_scale`.
      use_bias: whether to calculate the bias/intercept for this layer. If set to
        False, no bias/intercept will be used in calculations, e.g., the data is
        already centered.
      kernel_initializer: Initializer instance to use on the kernel matrix.
      bias_initializer: Initializer instance to use on the bias vector.
      kernel_regularizer: Regularizer instance to use on the kernel matrix.
      bias_regularizer: Regularizer instance to use on bias vector.
  
  Input shape:
      A tuple of 2 `(batch_size, input_dim)` dimensional inputs.
  
  Output shape:
      A single `(batch_size, input_dim)` dimensional output.
code: def compute_output_shape(self, input_shape):
      if not isinstance(input_shape, (tuple, list)):
          raise ValueError(
              "A `PolynomialCrossing` layer should be called "
              "on a list of inputs."
          )
      return input_shape[0]
  
file_path: addons/tensorflow_addons/layers/polynomial.py
imports: import tensorflow
  from typeguard import typechecked
  from tensorflow_addons.utils import types
label_desc: Use image node_id 5 for calling the PolynomialCrossing obj's underlying member method code with example usage: obj.compute_output_shape(input_shape) and returns: input_shape