code: def amari_alpha(logu, alpha=1.0, self_normalized=False, name=None):
      """The Amari-alpha Csiszar-function in log-space.
  
      A Csiszar-function is a member of,
  
      ```none
      F = { f:R_+ to R : f convex }.
      ```
  
      When `self_normalized = True`, the Amari-alpha Csiszar-function is:
  
      ```none
      f(u) = { -log(u) + (u - 1),     alpha = 0
             { u log(u) - (u - 1),    alpha = 1
             { [(u**alpha - 1) - alpha (u - 1)] / (alpha (alpha - 1)),    otherwise
      ```
  
      When `self_normalized = False` the `(u - 1)` terms are omitted.
  
      Warning: when `alpha != 0` and/or `self_normalized = True` this function makes
      non-log-space calculations and may therefore be numerically unstable for
      `|logu| >> 0`.
  
      For more information, see:
        A. Cichocki and S. Amari. "Families of Alpha-Beta-and GammaDivergences:
        Flexible and Robust Measures of Similarities." Entropy, vol. 12, no. 6, pp.
        1532-1568, 2010.
  
      Args:
        logu: `float`-like `Tensor` representing `log(u)` from above.
        alpha: `float`-like Python scalar. (See Mathematical Details for meaning.)
        self_normalized: Python `bool` indicating whether `f'(u=1)=0`. When
          `f'(u=1)=0` the implied Csiszar f-Divergence remains non-negative even
          when `p, q` are unnormalized measures.
        name: Python `str` name prefixed to Ops created by this function.
  
      Returns:
        amari_alpha_of_u: `float`-like `Tensor` of the Csiszar-function evaluated
          at `u = exp(logu)`.
  
      Raises:
        TypeError: if `alpha` is `None` or a `Tensor`.
        TypeError: if `self_normalized` is `None` or a `Tensor`.
      """
      with tf.name_scope(name or "amari_alpha"):
          if tf.get_static_value(alpha) is None:
              raise TypeError(
                  "Argument `alpha` cannot be `None` or `Tensor` type."
              )
          if tf.get_static_value(self_normalized) is None:
              raise TypeError(
                  "Argument `self_normalized` cannot be `None` or `Tensor` type."
              )
  
          logu = tf.convert_to_tensor(logu, name="logu")
  
          if alpha == 0.0:
              f = -logu
          elif alpha == 1.0:
              f = tf.exp(logu) * logu
          else:
              f = tf.math.expm1(alpha * logu) / (alpha * (alpha - 1.0))
  
          if not self_normalized:
              return f
  
          if alpha == 0.0:
              return f + tf.math.expm1(logu)
          elif alpha == 1.0:
              return f - tf.math.expm1(logu)
          else:
              return f - tf.math.expm1(logu) / (alpha - 1.0)
  
imports: import enum
  import functools
  import warnings
  import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python import monte_carlo
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.internal import nest_util
  from tensorflow_probability.python.internal import prefer_static
  from tensorflow_probability.python.internal import samplers
  from tensorflow_probability.python.internal.reparameterization import FULLY_REPARAMETERIZED
  from tensorflow_probability.python.stats.leave_one_out import log_soomean_exp
  from tensorflow.python.util import deprecation
label_desc: Use image node_id 2 for calling a global function with example usage: amari_alpha(logu, alpha, _normalized, name) and returns: f, unknown, unknown, unknown