docstr: API for face detection.
  
  Args:
      images (list(numpy.ndarray)): images data, shape of each is [H, W, C], color space must be BGR.
      paths (list[str]): The paths of images.
      batch_size (int): batch size of image tensor to be fed into the later classification network.
      use_gpu (bool): Whether to use gpu.
      visualization (bool): Whether to save image or not.
      output_dir (str): The path to store output images.
      use_multi_scale (bool): whether to enable multi-scale face detection. Enabling multi-scale face detection
          can increase the accuracy to detect faces, however,
          it reduce the prediction speed for the increase model calculation.
      shrink (float): parameter to control the resize scale in preprocess.
      confs_threshold (float): confidence threshold.
  
  Returns:
      res (list[dict]): The result of face detection and save path of images.
docstr_tok: ["API","for","face","detection",".","Args",":","images","(","list","(","numpy.ndarray",")",")",":","images","data",",","shape","of","each","is","[","H",",","W",",","C","]",",","color","space","must","be","BGR",".","paths","(","list","[","str","]",")",":","The","paths","of","images",".","batch_size","(","int",")",":","batch","size","of","image","tensor","to","be","fed","into","the","later","classification","network",".","use_gpu","(","bool",")",":","Whether","to","use","gpu",".","visualization","(","bool",")",":","Whether","to","save","image","or","not",".","output_dir","(","str",")",":","The","path","to","store","output","images",".","use_multi_scale","(","bool",")",":","whether","to","enable","multi-scale","face","detection",".","Enabling","multi-scale","face","detection","can","increase","the","accuracy","to","detect","faces",",","however",",","it","reduce","the","prediction","speed","for","the","increase","model","calculation",".","shrink","(","float",")",":","parameter","to","control","the","resize","scale","in","preprocess",".","confs_threshold","(","float",")",":","confidence","threshold",".","Returns",":","res","(","list","[","dict","]",")",":","The","result","of","face","detection","and","save","path","of","images","."]
code: def face_detection(
      self,
      images=None,
      paths=None,
      data=None,
      batch_size=1,
      use_gpu=False,
      visualization=False,
      output_dir="detection_result",
      use_multi_scale=False,
      shrink=0.5,
      confs_threshold=0.6,
  ):
      """
      API for face detection.
  
      Args:
          images (list(numpy.ndarray)): images data, shape of each is [H, W, C], color space must be BGR.
          paths (list[str]): The paths of images.
          batch_size (int): batch size of image tensor to be fed into the later classification network.
          use_gpu (bool): Whether to use gpu.
          visualization (bool): Whether to save image or not.
          output_dir (str): The path to store output images.
          use_multi_scale (bool): whether to enable multi-scale face detection. Enabling multi-scale face detection
              can increase the accuracy to detect faces, however,
              it reduce the prediction speed for the increase model calculation.
          shrink (float): parameter to control the resize scale in preprocess.
          confs_threshold (float): confidence threshold.
  
      Returns:
          res (list[dict]): The result of face detection and save path of images.
      """
      if use_gpu:
          try:
              _places = os.environ["CUDA_VISIBLE_DEVICES"]
              int(_places[0])
          except:
              raise RuntimeError(
                  "Environment Variable CUDA_VISIBLE_DEVICES is not set correctly. If you wanna use gpu, please set CUDA_VISIBLE_DEVICES as cuda_device_id."
              )
  
      # compatibility with older versions
      if data:
          if "image" in data:
              if paths is None:
                  paths = list()
              paths += data["image"]
          elif "data" in data:
              if images is None:
                  images = list()
              images += data["data"]
  
      # get all data
      all_element = list()
      for yield_data in reader(
          self.face_detector,
          shrink,
          confs_threshold,
          images,
          paths,
          use_gpu,
          use_multi_scale,
      ):
          all_element.append(yield_data)
  
      image_list = list()
      element_image_num = list()
      for i in range(len(all_element)):
          element_image = [
              handled["image"]
              for handled in all_element[i]["preprocessed"]
          ]
          element_image_num.append(len(element_image))
          image_list.extend(element_image)
  
      total_num = len(image_list)
      loop_num = int(np.ceil(total_num / batch_size))
  
      predict_out = np.zeros((1, 2))
      for iter_id in range(loop_num):
          batch_data = list()
          handle_id = iter_id * batch_size
          for element_id in range(batch_size):
              try:
                  batch_data.append(image_list[handle_id + element_id])
              except:
                  pass
  
          image_arr = np.squeeze(np.array(batch_data), axis=1)
  
          predictor = (
              self.gpu_predictor if use_gpu else self.cpu_predictor
          )
          input_names = predictor.get_input_names()
          input_handle = predictor.get_input_handle(input_names[0])
          input_handle.copy_from_cpu(image_arr)
  
          predictor.run()
          output_names = predictor.get_output_names()
          output_handle = predictor.get_output_handle(output_names[0])
          output_data = output_handle.copy_to_cpu()
  
          predict_out = np.concatenate((predict_out, output_data))
  
      predict_out = predict_out[1:]
      # postprocess one by one
      res = list()
      for i in range(len(all_element)):
          detect_faces_list = [
              handled["face"]
              for handled in all_element[i]["preprocessed"]
          ]
          interval_left = sum(element_image_num[0:i])
          interval_right = interval_left + element_image_num[i]
          out = postprocess(
              confidence_out=predict_out[interval_left:interval_right],
              org_im=all_element[i]["org_im"],
              org_im_path=all_element[i]["org_im_path"],
              detected_faces=detect_faces_list,
              output_dir=output_dir,
              visualization=visualization,
          )
          res.append(out)
      return res
  
imports: from __future__ import absolute_import
  from __future__ import division
  import argparse
  import ast
  import os
  import numpy
  from paddle.inference import Config
  from paddle.inference import create_predictor
  import paddlehub
  from .data_feed import reader
  from .processor import base64_to_cv2
  from .processor import postprocess
  from paddlehub.module.module import moduleinfo
  from paddlehub.module.module import runnable
  from paddlehub.module.module import serving
label_desc: Use image node_id 5 for calling the PyramidBoxLiteMobileMask obj's underlying member method code with example usage: obj.face_detection(images, paths, data, batch_size, use_gpu, visualization, output_dir, use_multi_scale, shrink, confs_threshold) and returns: res