  
      def padding_from_coverage(self, size, coverage_ratio):
          """ Return the image padding for a face from coverage_ratio set against a
              pre-padded training image """
          adjusted_ratio = coverage_ratio - (1 - self.extract_ratio)
          padding = round((size * adjusted_ratio) / 2)
          logger.trace(padding)
          return padding
  
      def load_feed_face(self, image, size=64, coverage_ratio=0.625, dtype=None):
 
</s> remove     def padding_from_coverage(self, size, coverage_ratio):
 </s> add     def _padding_from_coverage(self, size, coverage_ratio): </s> remove         """ Return a face in the correct dimensions for feeding into a NN

            Coverage ratio should be the ratio of the extracted image that was used for
            training """
 </s> add         """ Align a face in the correct dimensions for feeding into a model.

        Parameters
        ----------
        image: numpy.ndarray
            The image that contains the face to be aligned
        size: int
            The size of the face in pixels to be fed into the model
        coverage_ratio: float, optional
            the ratio of the extracted image that was used for training. Default: `0.625`
        dtype: str, optional
            Optionally set a ``dtype`` for the final face to be formatted in. Default: ``None``

        Notes
        -----
        This method must be executed to get access to the following `properties`:
            - :func:`feed_face`
            - :func:`feed_interpolators`
        """ </s> remove         """ Return a face in the correct dimensions for reference to the output from a NN

            Coverage ratio should be the ratio of the extracted image that was used for
            training """
 </s> add         """ Align a face in the correct dimensions for reference against the output from a model.

        Parameters
        ----------
        image: numpy.ndarray
            The image that contains the face to be aligned
        size: int
            The size of the face in pixels to be fed into the model
        coverage_ratio: float, optional
            the ratio of the extracted image that was used for training. Default: `0.625`
        dtype: str, optional
            Optionally set a ``dtype`` for the final face to be formatted in. Default: ``None``

        Notes
        -----
        This method must be executed to get access to the following `properties`:
            - :func:`reference_face`
            - :func:`reference_landmarks`
            - :func:`reference_matrix`
            - :func:`reference_interpolators`
        """ </s> remove                      self.feed_face.shape, self.feed_matrix)
 </s> add                      self.feed_face.shape, self._feed_matrix)
        adjusted_ratio = coverage_ratio - (1 - self._extract_ratio)
  
      def padding_from_coverage(self, size, coverage_ratio):
          """ Return the image padding for a face from coverage_ratio set against a
              pre-padded training image """
        adjusted_ratio = coverage_ratio - (1 - self._extract_ratio)
          padding = round((size * adjusted_ratio) / 2)
          logger.trace(padding)
          return padding
  
      def load_feed_face(self, image, size=64, coverage_ratio=0.625, dtype=None):
keep keep keep keep replace keep keep keep keep keep
 De-Multiprocess Extract (#871)

* requirements.txt: - Pin opencv to 4.1.1 (fixes cv2-dnn error)

* lib.face_detect.DetectedFace: change LandmarksXY to landmarks_xy. Add left, right, top, bottom attributes

* lib.model.session: Session manager for loading models into different graphs (for Nvidia + CPU)

* plugins.extract._base: New parent class for all extract plugins

* plugins.extract.pipeline. Remove MultiProcessing. Dynamically limit batchsize for Nvidia cards. Remove loglevel input

* S3FD + FAN plugins. Standardise to Keras version for all backends

* Standardize all extract plugins to new threaded codebase

* Documentation. Start implementing Numpy style docstrings for Sphinx Documentation

* Remove s3fd_amd. Change convert OTF to expect DetectedFace object

* faces_detect - clean up and documentation

* Remove PoolProcess

* Migrate manual tool to new extract workflow

* Remove AMD specific extractor code from cli and plugins

* Sort tool to new extract workflow

* Remove multiprocessing from project

* Remove multiprocessing queues from QueueManager

* Remove multiprocessing support from logger

* Move face_filter to new extraction pipeline

* Alignments landmarksXY > landmarks_xy and legacy handling

* Intercept get_backend for sphinx doc build

# Add Sphinx documentation 
lib/faces_detect.py