code: def visualize_image_attr_multiple(
      attr: ndarray,
      original_image: Union[None, ndarray],
      methods: List[str],
      signs: List[str],
      titles: Union[None, List[str]] = None,
      fig_size: Tuple[int, int] = (8, 6),
      use_pyplot: bool = True,
      **kwargs: Any,
  ):
      r"""
      Visualizes attribution using multiple visualization methods displayed
      in a 1 x k grid, where k is the number of desired visualizations.
  
      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 values in range 0-1 or 0-255. This is a necessary
                      argument for any visualization method which utilizes
                      the original image.
          methods (list[str]): List of strings of length k, defining method
                          for each visualization. Each method must be a valid
                          string argument for method to visualize_image_attr.
          signs (list[str]): List of strings of length k, defining signs for
                          each visualization. Each sign must be a valid
                          string argument for sign to visualize_image_attr.
          titles (list[str], optional): List of strings of length k, providing
                      a title string for each plot. If None is provided, no titles
                      are added to subplots.
                      Default: None
          fig_size (tuple, optional): Size of figure created.
                      Default: (8, 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.
          **kwargs (Any, optional): Any additional arguments which will be passed
                      to every individual visualization. Such arguments include
                      `show_colorbar`, `alpha_overlay`, `cmap`, etc.
  
  
      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 original image and heat map visualization of
          >>> # computed attributions side by side.
          >>> _ = visualize_image_attr_multiple(attribution, orig_image,
          >>>                     ["original_image", "heat_map"], ["all", "positive"])
      """
      assert len(methods) == len(
          signs
      ), "Methods and signs array lengths must match."
      if titles is not None:
          assert len(methods) == len(titles), (
              "If titles list is given, length must "
              "match that of methods list."
          )
      if use_pyplot:
          plt_fig = plt.figure(figsize=fig_size)
      else:
          plt_fig = Figure(figsize=fig_size)
      plt_axis = plt_fig.subplots(1, len(methods))
  
      # When visualizing one
      if len(methods) == 1:
          plt_axis = [plt_axis]
  
      for i in range(len(methods)):
          visualize_image_attr(
              attr,
              original_image=original_image,
              method=methods[i],
              sign=signs[i],
              plt_fig_axis=(plt_fig, plt_axis[i]),
              use_pyplot=False,
              title=titles[i] if titles else None,
              **kwargs,
          )
      plt_fig.tight_layout()
      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 6 for calling a global function with example usage: visualize_image_attr_multiple(attr, original_image, methods, signs, titles, fig_size, use_pyplot) and returns: plt_fig,  plt_axis