code: def visualize_image_attr(
      attr: ndarray,
      original_image: Union[None, ndarray] = None,
      method: str = "heat_map",
      sign: str = "absolute_value",
      plt_fig_axis: Union[None, Tuple[figure, axis]] = None,
      outlier_perc: Union[int, float] = 2,
      cmap: Union[None, str] = None,
      alpha_overlay: float = 0.5,
      show_colorbar: bool = False,
      title: Union[None, str] = None,
      fig_size: Tuple[int, int] = (6, 6),
      use_pyplot: bool = True,
  ):
      r"""
      Visualizes attribution for a given image by normalizing attribution values
      of the desired sign (positive, negative, absolute value, or all) and displaying
      them using the desired mode in a matplotlib figure.
  
      Args:
  
          attr (numpy.ndarray): Numpy array corresponding to attributions to be
                      visualized. Shape must be in the form (H, W, C), with
                      channels as last dimension. Shape must also match that of
                      the original image if provided.
          original_image (numpy.ndarray, optional): Numpy array corresponding to
                      original image. Shape must be in the form (H, W, C), with
                      channels as the last dimension. Image can be provided either
                      with float values in range 0-1 or int values between 0-255.
                      This is a necessary argument for any visualization method
                      which utilizes the original image.
                      Default: None
          method (str, optional): Chosen method for visualizing attribution.
                      Supported options are:
  
                      1. `heat_map` - Display heat map of chosen attributions
  
                      2. `blended_heat_map` - Overlay heat map over greyscale
                         version of original image. Parameter alpha_overlay
                         corresponds to alpha of heat map.
  
                      3. `original_image` - Only display original image.
  
                      4. `masked_image` - Mask image (pixel-wise multiply)
                         by normalized attribution values.
  
                      5. `alpha_scaling` - Sets alpha channel of each pixel
                         to be equal to normalized attribution value.
  
                      Default: `heat_map`
          sign (str, optional): Chosen sign of attributions to visualize. Supported
                      options are:
  
                      1. `positive` - Displays only positive pixel attributions.
  
                      2. `absolute_value` - Displays absolute value of
                         attributions.
  
                      3. `negative` - Displays only negative pixel attributions.
  
                      4. `all` - Displays both positive and negative attribution
                         values. This is not supported for `masked_image` or
                         `alpha_scaling` modes, since signed information cannot
                         be represented in these modes.
  
                      Default: `absolute_value`
          plt_fig_axis (tuple, optional): Tuple of matplotlib.pyplot.figure and axis
                      on which to visualize. If None is provided, then a new figure
                      and axis are created.
                      Default: None
          outlier_perc (float or int, optional): Top attribution values which
                      correspond to a total of outlier_perc percentage of the
                      total attribution are set to 1 and scaling is performed
                      using the minimum of these values. For sign=`all`, outliers
                      and scale value are computed using absolute value of
                      attributions.
                      Default: 2
          cmap (str, optional): String corresponding to desired colormap for
                      heatmap visualization. This defaults to "Reds" for negative
                      sign, "Blues" for absolute value, "Greens" for positive sign,
                      and a spectrum from red to green for all. Note that this
                      argument is only used for visualizations displaying heatmaps.
                      Default: None
          alpha_overlay (float, optional): Alpha to set for heatmap when using
                      `blended_heat_map` visualization mode, which overlays the
                      heat map over the greyscaled original image.
                      Default: 0.5
          show_colorbar (bool, optional): Displays colorbar for heatmap below
                      the visualization. If given method does not use a heatmap,
                      then a colormap axis is created and hidden. This is
                      necessary for appropriate alignment when visualizing
                      multiple plots, some with colorbars and some without.
                      Default: False
          title (str, optional): Title string for plot. If None, no title is
                      set.
                      Default: None
          fig_size (tuple, optional): Size of figure created.
                      Default: (6,6)
          use_pyplot (bool, optional): If true, uses pyplot to create and show
                      figure and displays the figure after creating. If False,
                      uses Matplotlib object oriented API and simply returns a
                      figure object without showing.
                      Default: True.
  
      Returns:
          2-element tuple of **figure**, **axis**:
          - **figure** (*matplotlib.pyplot.figure*):
                      Figure object on which visualization
                      is created. If plt_fig_axis argument is given, this is the
                      same figure provided.
          - **axis** (*matplotlib.pyplot.axis*):
                      Axis object on which visualization
                      is created. If plt_fig_axis argument is given, this is the
                      same axis provided.
  
      Examples::
  
          >>> # ImageClassifier takes a single input tensor of images Nx3x32x32,
          >>> # and returns an Nx10 tensor of class probabilities.
          >>> net = ImageClassifier()
          >>> ig = IntegratedGradients(net)
          >>> # Computes integrated gradients for class 3 for a given image .
          >>> attribution, delta = ig.attribute(orig_image, target=3)
          >>> # Displays blended heat map visualization of computed attributions.
          >>> _ = visualize_image_attr(attribution, orig_image, "blended_heat_map")
      """
      # Create plot if figure, axis not provided
      if plt_fig_axis is not None:
          plt_fig, plt_axis = plt_fig_axis
      else:
          if use_pyplot:
              plt_fig, plt_axis = plt.subplots(figsize=fig_size)
          else:
              plt_fig = Figure(figsize=fig_size)
              plt_axis = plt_fig.subplots()
  
      if original_image is not None:
          if np.max(original_image) <= 1.0:
              original_image = _prepare_image(original_image * 255)
      elif (
          ImageVisualizationMethod[method]
          != ImageVisualizationMethod.heat_map
      ):
          raise ValueError(
              "Original Image must be provided for"
              "any visualization other than heatmap."
          )
  
      # Remove ticks and tick labels from plot.
      plt_axis.xaxis.set_ticks_position("none")
      plt_axis.yaxis.set_ticks_position("none")
      plt_axis.set_yticklabels([])
      plt_axis.set_xticklabels([])
      plt_axis.grid(visible=False)
  
      heat_map = None
      # Show original image
      if (
          ImageVisualizationMethod[method]
          == ImageVisualizationMethod.original_image
      ):
          assert (
              original_image is not None
          ), "Original image expected for original_image method."
          if (
              len(original_image.shape) > 2
              and original_image.shape[2] == 1
          ):
              original_image = np.squeeze(original_image, axis=2)
          plt_axis.imshow(original_image)
      else:
          # Choose appropriate signed attributions and normalize.
          norm_attr = _normalize_attr(
              attr, sign, outlier_perc, reduction_axis=2
          )
  
          # Set default colormap and bounds based on sign.
          if VisualizeSign[sign] == VisualizeSign.all:
              default_cmap = LinearSegmentedColormap.from_list(
                  "RdWhGn", ["red", "white", "green"]
              )
              vmin, vmax = -1, 1
          elif VisualizeSign[sign] == VisualizeSign.positive:
              default_cmap = "Greens"
              vmin, vmax = 0, 1
          elif VisualizeSign[sign] == VisualizeSign.negative:
              default_cmap = "Reds"
              vmin, vmax = 0, 1
          elif VisualizeSign[sign] == VisualizeSign.absolute_value:
              default_cmap = "Blues"
              vmin, vmax = 0, 1
          else:
              raise AssertionError("Visualize Sign type is not valid.")
          cmap = cmap if cmap is not None else default_cmap
  
          # Show appropriate image visualization.
          if (
              ImageVisualizationMethod[method]
              == ImageVisualizationMethod.heat_map
          ):
              heat_map = plt_axis.imshow(
                  norm_attr, cmap=cmap, vmin=vmin, vmax=vmax
              )
          elif (
              ImageVisualizationMethod[method]
              == ImageVisualizationMethod.blended_heat_map
          ):
              assert (
                  original_image is not None
              ), "Original Image expected for blended_heat_map method."
              plt_axis.imshow(
                  np.mean(original_image, axis=2), cmap="gray"
              )
              heat_map = plt_axis.imshow(
                  norm_attr,
                  cmap=cmap,
                  vmin=vmin,
                  vmax=vmax,
                  alpha=alpha_overlay,
              )
          elif (
              ImageVisualizationMethod[method]
              == ImageVisualizationMethod.masked_image
          ):
              assert VisualizeSign[sign] != VisualizeSign.all, (
                  "Cannot display masked image with both positive and negative "
                  "attributions, choose a different sign option."
              )
              plt_axis.imshow(
                  _prepare_image(
                      original_image * np.expand_dims(norm_attr, 2)
                  )
              )
          elif (
              ImageVisualizationMethod[method]
              == ImageVisualizationMethod.alpha_scaling
          ):
              assert VisualizeSign[sign] != VisualizeSign.all, (
                  "Cannot display alpha scaling with both positive and negative "
                  "attributions, choose a different sign option."
              )
              plt_axis.imshow(
                  np.concatenate(
                      [
                          original_image,
                          _prepare_image(
                              np.expand_dims(norm_attr, 2) * 255
                          ),
                      ],
                      axis=2,
                  )
              )
          else:
              raise AssertionError(
                  "Visualize Method type is not valid."
              )
  
      # Add colorbar. If given method is not a heatmap and no colormap is relevant,
      # then a colormap axis is created and hidden. This is necessary for appropriate
      # alignment when visualizing multiple plots, some with heatmaps and some
      # without.
      if show_colorbar:
          axis_separator = make_axes_locatable(plt_axis)
          colorbar_axis = axis_separator.append_axes(
              "bottom", size="5%", pad=0.1
          )
          if heat_map:
              plt_fig.colorbar(
                  heat_map, orientation="horizontal", cax=colorbar_axis
              )
          else:
              colorbar_axis.axis("off")
      if title:
          plt_axis.set_title(title)
  
      if use_pyplot:
          plt.show()
  
      return plt_fig, plt_axis
  
imports: import warnings
  from enum import Enum
  from typing import Any, Iterable, List, Optional, Tuple, Union
  import numpy
  from matplotlib import cm, colors, pyplot
  from matplotlib.collections import LineCollection
  from matplotlib.colors import LinearSegmentedColormap
  from matplotlib.figure import Figure
  from matplotlib.pyplot import axis, figure
  from mpl_toolkits.axes_grid1 import make_axes_locatable
  from numpy import ndarray
label_desc: Use image node_id 5 for calling a global function with example usage: visualize_image_attr(attr, original_image, method, sign, plt_fig_axis, outlier_perc, cmap, alpha_overlay, show_colorbar, title, fig_size, use_pyplot) and returns: plt_fig,  plt_axis