code: def visualize(cfg):
      """
      Perform layer weights and activations visualization on the model.
      Args:
          cfg (CfgNode): configs. Details can be found in
              slowfast/config/defaults.py
      """
      if cfg.TENSORBOARD.ENABLE and (
          cfg.TENSORBOARD.MODEL_VIS.ENABLE
          or cfg.TENSORBOARD.WRONG_PRED_VIS.ENABLE
      ):
          # Set up environment.
          du.init_distributed_training(cfg)
          # Set random seed from configs.
          np.random.seed(cfg.RNG_SEED)
          torch.manual_seed(cfg.RNG_SEED)
  
          # Setup logging format.
          logging.setup_logging(cfg.OUTPUT_DIR)
  
          # Print config.
          logger.info("Model Visualization with config:")
          logger.info(cfg)
  
          # Build the video model and print model statistics.
          model = build_model(cfg)
          model.eval()
          if du.is_master_proc() and cfg.LOG_MODEL_INFO:
              misc.log_model_info(model, cfg, use_train_input=False)
  
          cu.load_test_checkpoint(cfg, model)
  
          # Create video testing loaders.
          vis_loader = loader.construct_loader(cfg, "test")
  
          if cfg.DETECTION.ENABLE:
              assert (
                  cfg.NUM_GPUS == cfg.TEST.BATCH_SIZE
                  or cfg.NUM_GPUS == 0
              )
  
          # Set up writer for logging to Tensorboard format.
          if du.is_master_proc(cfg.NUM_GPUS * cfg.NUM_SHARDS):
              writer = tb.TensorboardWriter(cfg)
          else:
              writer = None
          if cfg.TENSORBOARD.PREDICTIONS_PATH != "":
              assert (
                  not cfg.DETECTION.ENABLE
              ), "Detection is not supported."
              logger.info(
                  "Visualizing class-level performance from saved results..."
              )
              if writer is not None:
                  with pathmgr.open(
                      cfg.TENSORBOARD.PREDICTIONS_PATH, "rb"
                  ) as f:
                      preds, labels = pickle.load(f, encoding="latin1")
  
                  writer.plot_eval(preds, labels)
  
          if cfg.TENSORBOARD.MODEL_VIS.ENABLE:
              if cfg.TENSORBOARD.MODEL_VIS.GRAD_CAM.ENABLE:
                  assert (
                      not cfg.DETECTION.ENABLE
                  ), "Detection task is currently not supported for Grad-CAM visualization."
                  if cfg.MODEL.ARCH in cfg.MODEL.SINGLE_PATHWAY_ARCH:
                      assert (
                          len(
                              cfg.TENSORBOARD.MODEL_VIS.GRAD_CAM.LAYER_LIST
                          )
                          == 1
                      ), "The number of chosen CNN layers must be equal to the number of pathway(s), given {} layer(s).".format(
                          len(
                              cfg.TENSORBOARD.MODEL_VIS.GRAD_CAM.LAYER_LIST
                          )
                      )
                  elif cfg.MODEL.ARCH in cfg.MODEL.MULTI_PATHWAY_ARCH:
                      assert (
                          len(
                              cfg.TENSORBOARD.MODEL_VIS.GRAD_CAM.LAYER_LIST
                          )
                          == 2
                      ), "The number of chosen CNN layers must be equal to the number of pathway(s), given {} layer(s).".format(
                          len(
                              cfg.TENSORBOARD.MODEL_VIS.GRAD_CAM.LAYER_LIST
                          )
                      )
                  else:
                      raise NotImplementedError(
                          "Model arch {} is not in {}".format(
                              cfg.MODEL.ARCH,
                              cfg.MODEL.SINGLE_PATHWAY_ARCH
                              + cfg.MODEL.MULTI_PATHWAY_ARCH,
                          )
                      )
              logger.info(
                  "Visualize model analysis for {} iterations".format(
                      len(vis_loader)
                  )
              )
              # Run visualization on the model
              run_visualization(vis_loader, model, cfg, writer)
          if cfg.TENSORBOARD.WRONG_PRED_VIS.ENABLE:
              logger.info(
                  "Visualize Wrong Predictions for {} iterations".format(
                      len(vis_loader)
                  )
              )
              perform_wrong_prediction_vis(vis_loader, model, cfg)
  
          if writer is not None:
              writer.close()
  
file_path: SlowFast/tools/visualization.py
imports: import numpy
  import pickle
  import torch
  import tqdm
  import slowfast.datasets.utils
  import slowfast.utils.checkpoint
  import slowfast.utils.distributed
  import slowfast.utils.logging
  import slowfast.utils.misc
  import slowfast.visualization.tensorboard_vis
  from slowfast.datasets import loader
  from slowfast.models import build_model
  from slowfast.utils.env import pathmgr
  from slowfast.visualization.gradcam_utils import GradCAM
  from slowfast.visualization.prediction_vis import WrongPredictionVis
  from slowfast.visualization.utils import GetWeightAndActivation, process_layer_index_data
  from slowfast.visualization.video_visualizer import VideoVisualizer
label_desc: Use image node_id 3 for calling a global function with example usage: visualize(cfg) without return types