code: def __find_bulk_embeddings(
      employees: List[str],
      model_name: str = "VGG-Face",
      target_size: tuple = (224, 224),
      detector_backend: str = "opencv",
      enforce_detection: bool = True,
      align: bool = True,
      normalization: str = "base",
      silent: bool = False,
  ):
      """
      Find embeddings of a list of images
  
      Args:
          employees (list): list of exact image paths
          model_name (str): facial recognition model name
          target_size (tuple): expected input shape of facial
              recognition model
          detector_backend (str): face detector model name
          enforce_detection (bool): set this to False if you
              want to proceed when you cannot detect any face
          align (bool): enable or disable alignment of image
              before feeding to facial recognition model
          normalization (bool): normalization technique
          silent (bool): enable or disable informative logging
      Returns:
          representations (list): pivot list of embeddings with
              image name and detected face area's coordinates
      """
      representations = []
      for employee in tqdm(
          employees,
          desc="Finding representations",
          disable=silent,
      ):
          img_objs = functions.extract_faces(
              img=employee,
              target_size=target_size,
              detector_backend=detector_backend,
              grayscale=False,
              enforce_detection=enforce_detection,
              align=align,
          )
  
          for img_content, img_region, _ in img_objs:
              embedding_obj = representation.represent(
                  img_path=img_content,
                  model_name=model_name,
                  enforce_detection=enforce_detection,
                  detector_backend="skip",
                  align=align,
                  normalization=normalization,
              )
  
              img_representation = embedding_obj[0]["embedding"]
  
              instance = []
              instance.append(employee)
              instance.append(img_representation)
              instance.append(img_region["x"])
              instance.append(img_region["y"])
              instance.append(img_region["w"])
              instance.append(img_region["h"])
              representations.append(instance)
      return representations
  
file_path: deepface/deepface/modules/recognition.py
imports: import os
  import pickle
  from typing import List, Union
  import time
  import numpy
  import pandas
  from tqdm import tqdm
  from deepface.commons import functions, distance
  from deepface.commons.logger import Logger
  from deepface.modules import representation
label_desc: Use image node_id 3 for calling a global function with example usage: __find_bulk_embeddings(employees, model_name, target_size, detector_backend, enforce_detection, align, normalization, silent) and returns: representations