code: def interpret_output(self, output):
      probs = np.zeros((7, 7, 2, 20))
      class_probs = np.reshape(output[0:980], (7, 7, 20))
      scales = np.reshape(output[980:1078], (7, 7, 2))
      boxes = np.reshape(output[1078:], (7, 7, 2, 4))
      offset = np.transpose(
          np.reshape(np.array([np.arange(7)] * 14), (2, 7, 7)),
          (1, 2, 0),
      )
  
      boxes[:, :, :, 0] += offset
      boxes[:, :, :, 1] += np.transpose(offset, (1, 0, 2))
      boxes[:, :, :, 0:2] = boxes[:, :, :, 0:2] / 7.0
      boxes[:, :, :, 2] = np.multiply(
          boxes[:, :, :, 2], boxes[:, :, :, 2]
      )
      boxes[:, :, :, 3] = np.multiply(
          boxes[:, :, :, 3], boxes[:, :, :, 3]
      )
  
      boxes[:, :, :, 0] *= self.w_img
      boxes[:, :, :, 1] *= self.h_img
      boxes[:, :, :, 2] *= self.w_img
      boxes[:, :, :, 3] *= self.h_img
  
      for i in range(2):
          for j in range(20):
              probs[:, :, i, j] = np.multiply(
                  class_probs[:, :, j], scales[:, :, i]
              )
  
      filter_mat_probs = np.array(probs >= self.threshold, dtype="bool")
      filter_mat_boxes = np.nonzero(filter_mat_probs)
      boxes_filtered = boxes[
          filter_mat_boxes[0], filter_mat_boxes[1], filter_mat_boxes[2]
      ]
      probs_filtered = probs[filter_mat_probs]
      classes_num_filtered = np.argmax(filter_mat_probs, axis=3)[
          filter_mat_boxes[0], filter_mat_boxes[1], filter_mat_boxes[2]
      ]
  
      argsort = np.array(np.argsort(probs_filtered))[::-1]
      boxes_filtered = boxes_filtered[argsort]
      probs_filtered = probs_filtered[argsort]
      classes_num_filtered = classes_num_filtered[argsort]
  
      for i in range(len(boxes_filtered)):
          if probs_filtered[i] == 0:
              continue
          for j in range(i + 1, len(boxes_filtered)):
              if (
                  self.iou(boxes_filtered[i], boxes_filtered[j])
                  > self.iou_threshold
              ):
                  probs_filtered[j] = 0.0
  
      filter_iou = np.array(probs_filtered > 0.0, dtype="bool")
      boxes_filtered = boxes_filtered[filter_iou]
      probs_filtered = probs_filtered[filter_iou]
      classes_num_filtered = classes_num_filtered[filter_iou]
  
      result = []
      for i in range(len(boxes_filtered)):
          result.append(
              [
                  self.classes[classes_num_filtered[i]],
                  boxes_filtered[i][0],
                  boxes_filtered[i][1],
                  boxes_filtered[i][2],
                  boxes_filtered[i][3],
                  probs_filtered[i],
              ]
          )
  
      return result
  
file_path: AdvBox/applications/StealthTshirt/StealthTshirtDemo.py
imports: import numpy
  import tensorflow
  import cv2
  import time
  import sys
  import os
  import pdb
label_desc: Use image node_id 8 for calling the Faster_YOLO obj's underlying member method code with example usage: obj.interpret_output(output) and returns: result