code: def _calculate_vis_output(
      self,
      inputs,
      additional_forward_args,
      label,
      target=None,
      single_model_index=None,
  ) -> Optional[List[VisualizationOutput]]:
      # Use all models, unless the user wants to render data for a particular one
      models_used = (
          [self.models[single_model_index]]
          if single_model_index is not None
          else self.models
      )
      results = []
      for model_index, model in enumerate(models_used):
          # Get list of model visualizations for each input
          actual_label_output = None
          if label is not None and len(label) > 0:
              label_index = int(label[0])
              actual_label_output = OutputScore(
                  score=100,
                  index=label_index,
                  label=self.classes[label_index],
              )
  
          (
              predicted_scores,
              baselines,
              transformed_inputs,
          ) = self.attribution_calculation.calculate_predicted_scores(
              inputs, additional_forward_args, model
          )
  
          # Filter based on UI configuration
          if (
              actual_label_output is None
              or not self._should_keep_prediction(
                  predicted_scores, actual_label_output
              )
          ):
              continue
  
          if target is None:
              target = (
                  predicted_scores[0].index
                  if len(predicted_scores) > 0
                  else None
              )
  
          # attributions are given per input*
          # inputs given to the model are described via `self.features`
          #
          # *an input contains multiple features that represent it
          #   e.g. all the pixels that describe an image is an input
  
          attrs_per_feature = (
              self.attribution_calculation.calculate_attribution(
                  baselines,
                  transformed_inputs,
                  additional_forward_args,
                  target,
                  self._config.attribution_method,
                  self._config.attribution_arguments,
                  model,
              )
          )
  
          net_contrib = (
              self.attribution_calculation.calculate_net_contrib(
                  attrs_per_feature
              )
          )
  
          # the features per input given
          features_per_input = [
              feature.visualize(attr, data, contrib)
              for feature, attr, data, contrib in zip(
                  self.features, attrs_per_feature, inputs, net_contrib
              )
          ]
  
          results.append(
              VisualizationOutput(
                  feature_outputs=features_per_input,
                  actual=actual_label_output,
                  predicted=predicted_scores,
                  active_index=target
                  if target is not None
                  else actual_label_output.index,
                  # Even if we only iterated over one model, the index should be fixed
                  # to show the index the model would have had in the list
                  model_index=single_model_index
                  if single_model_index is not None
                  else model_index,
              )
          )
  
      return results if results else None
  
imports: from collections import namedtuple
  from itertools import cycle
  from typing import Any, Callable, Dict, Iterable, List, NamedTuple, Optional, Tuple, Union
  import torch
  from captum.attr import IntegratedGradients
  from captum.attr._utils.batching import _batched_generator
  from captum.insights.attr_vis.attribution_calculation import AttributionCalculation, OutputScore
  from captum.insights.attr_vis.config import ATTRIBUTION_METHOD_CONFIG, ATTRIBUTION_NAMES_TO_METHODS
  from captum.insights.attr_vis.features import BaseFeature
  from captum.insights.attr_vis.server import namedtuple_to_dict
  from captum.log import log_usage
  from torch import Tensor
  from torch.nn import Module
label_desc: Use image node_id 10 for calling the AttributionVisualizer obj's underlying member method code with example usage: obj._calculate_vis_output(inputs, additional_forward_args, label, target, single_model_index) and returns: unknown