code: def excess_wrong_bits(f, *args):
      """Returns excess inaccuracy of 32-bit `f(*args)`, relative to conditioning.
  
      If this is positive, that suggests the implementation of `f` is
      introducing unnecessary numerical error at the given arguments.
  
      This function assumes that `f` is differentiable, and that numerical
      error when computing `f` or its derivatives in float64 is
      negligible.  One necessary condition for this to work correctly is
      that `f` be _dtype-polymorphic_: the dtype in which computations
      internal to `f` (and its derivatives) are performed should match the
      dtype of the arguments of `f`.
  
      Args:
        f: Function whose accuracy to evaluate.  Must be differentiable
          and dtype-polymorphic.
        *args: Arguments at which to test the accuracy of `f`.
  
      Returns:
        wrong: The wrong bits when computing `f(*args)` in float32, in excess
          of what would be expected from `f` being ill-conditioned.
      """
      err = relative_error_at(f, *args)
      logging.vlog(1, "Relative error: %s", err)
      conditioning_err = error_due_to_ill_conditioning(f, *args)
      logging.vlog(
          1,
          "Relative error due to input rounding: %s",
          conditioning_err,
      )
      wrong = wrong_bits(err)
      conditioning = wrong_bits(conditioning_err)
      logging.vlog(1, "Wrong bits: %s", wrong)
      logging.vlog(
          1, "Wrong bits due to input rounding: %s", conditioning
      )
      return wrong - conditioning
  
file_path: probability/tensorflow_probability/python/internal/numerics_testing.py
imports: import functools
  from absl import logging
  import numpy
  import tensorflow.compat.v2
  from tensorflow_probability.python.internal import dtype_util
  from tensorflow_probability.python.math import gradient
label_desc: Use image node_id 11 for calling a global function with example usage: excess_wrong_bits(f) and returns: unknown