code: def ExpNormalized(
      gamma: float = 1, shift: float = -1, do_clip: bool = False
  ) -> InternalLayer:
      """Simulates the "Gaussian normalized kernel".
  
      See page 6 in
      "`Neural Kernels Without Tangents <https://arxiv.org/abs/2003.02237>`_".
  
      Args:
        gamma: exponent scalar coefficient.
        shift: shift exponentiated normalized covariance by this much.
        do_clip: True to clip normalized covariance, potentially improving accuracy.
  
      Returns:
        `(init_fn, apply_fn, kernel_fn)`.
  
      Raises:
        NotImplementedError: if finite width `apply_fn` is called.
      """
  
      def kernel_fn(k: Kernel) -> Kernel:
          cov1, cov2, nngp, ntk = k.cov1, k.cov2, k.nngp, k.ntk
          prod11, prod12, prod22 = get_diagonal_outer_prods(
              cov1, cov2, k.diagonal_batch, k.diagonal_spatial, op.mul
          )
          tol = 1e-30
          prod11 = _sqrt(prod11, tol)
          prod12 = _sqrt(prod12, tol)
          prod22 = _sqrt(prod22, tol) if prod22 is not None else None
  
          def exp(cov, prod):
              if cov is not None:
                  cov /= prod
                  if do_clip:
                      cov = jnp.clip(cov, -1, 1)
                  cov = jnp.exp(gamma * (cov + shift))
              return cov
  
          exp12 = exp(nngp, prod12)
  
          return k.replace(
              nngp=prod12 * exp12,
              cov1=prod11 * exp(cov1, prod11),
              cov2=None if cov2 is None else prod22 * exp(cov2, prod22),
              ntk=ntk if ntk is None else gamma * ntk * exp12,
          )
  
      return _elementwise(None, "ExpNormalized", kernel_fn)
  
imports: import functools
  import operator
  from typing import Callable, Optional, Sequence
  import warnings
  import jax
  from jax import custom_jvp
  from jax import grad
  from jax import numpy
  from jax import vmap
  from jax.scipy.special import erf
  import numpy
  import scipy
  from ..utils import utils
  from ..utils.kernel import Kernel
  from ..utils.typing import InternalLayer
  from ..utils.typing import LayerKernelFn
  from .requirements import Diagonal
  from .requirements import get_diagonal
  from .requirements import get_diagonal_outer_prods
  from .requirements import layer
  from .requirements import requires
  from .requirements import supports_masking
label_desc: Use image node_id 15 for calling a global function with example usage: ExpNormalized(gamma, shift, do_clip) and returns: _elementwise, k, cov