class_docstr: Applies layer normalization to the n-dimensional input tensor:
  
  ``out = gamma * (input - mean) / sqrt(variance + epsilon) + beta``.
  
  Parameters
  ----------
  x: tensor<*?, T> (Required)
      * Input tensor
  axes: const<[K], i32> (Optional)
      * defaults to ``None`` (all dimensions)
      * Dimensions to perform layer normalization.
  gamma: const tensor<[K], T> (Optional)
      * defaults to all ``1s``.
      * same shape as normalized_shape.
  beta: const tensor<[K], T> (Optional)
      * defaults to all ``0s``.
      * same shape as normalized_shape.
  epsilon: const fp32 (Optional)
      * defaults to ``1e-5``.
      * Small constant to avoid division by ``0``.
  
  Returns
  -------
  tensor<*?, T>:
  * tensor with same shape and type as the input tensor ``x``.
code: def value_inference(self):
      def np_layer_norm(x, axes, gamma, beta, epsilon=1e-5):
          normalized_shape = x.shape[-len(axes) :]
          gamma = (
              np.ones(shape=normalized_shape)
              if gamma is None
              else gamma
          )
          beta = (
              np.zeros(shape=normalized_shape) if beta is None else beta
          )
          num = x - np.mean(x, axis=tuple(axes), keepdims=True)
          dem = np.sqrt(
              np.sum(np.square(num), axis=tuple(axes), keepdims=True)
              / np.prod(normalized_shape)
              + epsilon
          )
          return num / dem * gamma + beta
  
      _axes = self.x.shape if self.axes is None else self.axes.val
      _gamma = None if self.gamma is None else self.gamma.val
      _beta = None if self.beta is None else self.beta.val
      return np_layer_norm(
          self.x.val, _axes, _gamma, _beta, self.epsilon.val
      )
  
imports: from ._op_reqs import *
label_desc: Use image node_id 3 for calling the layer_norm obj's underlying member method code with example usage: obj.value_inference() and returns: np_layer_norm, unknown