Module facetorch.analyzer.predictor.post

Classes

class BasePredPostProcessor (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str])

Base class for predictor post processors.

All predictor post processors should subclass it. All subclass should overwrite:

• Methods:run, used for running the processing

Args

device : torch.device

Torch device cpu or cuda.

transform : transforms.Compose

Transform compose object to be applied to the image.

optimize_transform : bool

Whether to optimize the transform.

labels : List[str]

List of labels.

Expand source code

class BasePredPostProcessor(BaseProcessor):
    @Timer(
        "BasePredPostProcessor.__init__",
        "{name}: {milliseconds:.2f} ms",
        logger=logger.debug,
    )
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
    ):
        """Base class for predictor post processors.

        All predictor post processors should subclass it.
        All subclass should overwrite:

        - Methods:``run``, used for running the processing

        Args:
            device (torch.device): Torch device cpu or cuda.
            transform (transforms.Compose): Transform compose object to be applied to the image.
            optimize_transform (bool): Whether to optimize the transform.
            labels (List[str]): List of labels.

        """
        super().__init__(transform, device, optimize_transform)
        self.labels = labels

    def create_pred_list(
        self, preds: torch.Tensor, indices: List[int]
    ) -> List[Prediction]:
        """Create a list of predictions.

        Args:
            preds (torch.Tensor): Tensor of predictions, shape (batch, _).
            indices (List[int]): List of label indices, one for each sample.

        Returns:
            List[Prediction]: List of predictions.

        """
        assert (
            len(indices) == preds.shape[0]
        ), "Predictions and indices must have the same length."

        pred_labels = [self.labels[indx] for indx in indices]

        pred_list = []
        for i, label in enumerate(pred_labels):
            pred = Prediction(label, preds[i])
            pred_list.append(pred)
        return pred_list

    @abstractmethod
    def run(self, preds: Union[torch.Tensor, Tuple[torch.Tensor]]) -> List[Prediction]:
        """Abstract method that runs the predictor post processing functionality and returns a list of prediction data structures, one for each face in the batch.

        Args:
            preds (Union[torch.Tensor, Tuple[torch.Tensor]]): Output of the predictor model.

        Returns:
            List[Prediction]: List of predictions.

        """

Ancestors

• BaseProcessor

Subclasses

• PostArgMax
• PostEmbedder
• PostLabelConfidencePairs
• PostMultiLabel
• PostSigmoidBinary

Methods

def create_pred_list(self, preds: torch.Tensor, indices: List[int]) ‑> List[Prediction]

Create a list of predictions.

Args

preds : torch.Tensor

Tensor of predictions, shape (batch, _).

indices : List[int]

List of label indices, one for each sample.

Returns

List[Prediction]

List of predictions.

def run(self, preds: Union[torch.Tensor, Tuple[torch.Tensor]]) ‑> List[Prediction]

Abstract method that runs the predictor post processing functionality and returns a list of prediction data structures, one for each face in the batch.

Args

preds : Union[torch.Tensor, Tuple[torch.Tensor]]

Output of the predictor model.

Returns

List[Prediction]

List of predictions.

Inherited members

• BaseProcessor:
  • optimize

class PostArgMax (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str], dim: int)

Initialize the predictor postprocessor that runs argmax on the prediction tensor and returns a list of prediction data structures.

Args

transform : Compose

Composed Torch transform object.

device : torch.device

Torch device cpu or cuda.

optimize_transform : bool

Whether to optimize the transform using TorchScript.

labels : List[str]

List of labels.

dim : int

Axis along which to apply the argmax.

Expand source code

class PostArgMax(BasePredPostProcessor):
    @Timer("PostArgMax.__init__", "{name}: {milliseconds:.2f} ms", logger=logger.debug)
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
        dim: int,
    ):
        """Initialize the predictor postprocessor that runs argmax on the prediction tensor and returns a list of prediction data structures.

        Args:
            transform (Compose): Composed Torch transform object.
            device (torch.device): Torch device cpu or cuda.
            optimize_transform (bool): Whether to optimize the transform using TorchScript.
            labels (List[str]): List of labels.
            dim (int): Axis along which to apply the argmax.
        """
        super().__init__(transform, device, optimize_transform, labels)
        self.dim = dim

    @Timer("PostArgMax.run", "{name}: {milliseconds:.2f} ms", logger=logger.debug)
    def run(self, preds: torch.Tensor) -> List[Prediction]:
        """Post-processes the prediction tensor using argmax and returns a list of prediction data structures, one for each face.

        Args:
            preds (torch.Tensor): Batch prediction tensor.

        Returns:
            List[Prediction]: List of prediction data structures containing the predicted labels and confidence scores for each face in the batch.
        """
        indices = torch.argmax(preds, dim=self.dim).cpu().numpy().tolist()
        pred_list = self.create_pred_list(preds, indices)

        return pred_list

Ancestors

• BasePredPostProcessor
• BaseProcessor

Methods

def run(self, preds: torch.Tensor) ‑> List[Prediction]

Post-processes the prediction tensor using argmax and returns a list of prediction data structures, one for each face.

Args

preds : torch.Tensor

Batch prediction tensor.

Returns

List[Prediction]

List of prediction data structures containing the predicted labels and confidence scores for each face in the batch.

Inherited members

• BasePredPostProcessor:
  • create_pred_list
  • optimize

class PostSigmoidBinary (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str], threshold: float = 0.5)

Initialize the predictor postprocessor that runs sigmoid on the prediction tensor and returns a list of prediction data structures.

Args

transform : Compose

Composed Torch transform object.

device : torch.device

Torch device cpu or cuda.

optimize_transform : bool

Whether to optimize the transform using TorchScript.

labels : List[str]

List of labels.

threshold : float

Probability threshold for positive class.

Expand source code

class PostSigmoidBinary(BasePredPostProcessor):
    @Timer(
        "PostSigmoidBinary.__init__",
        "{name}: {milliseconds:.2f} ms",
        logger=logger.debug,
    )
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
        threshold: float = 0.5,
    ):
        """Initialize the predictor postprocessor that runs sigmoid on the prediction tensor and returns a list of prediction data structures.

        Args:
            transform (Compose): Composed Torch transform object.
            device (torch.device): Torch device cpu or cuda.
            optimize_transform (bool): Whether to optimize the transform using TorchScript.
            labels (List[str]): List of labels.
            threshold (float): Probability threshold for positive class.
        """
        super().__init__(transform, device, optimize_transform, labels)
        self.threshold = threshold

    @Timer(
        "PostSigmoidBinary.run", "{name}: {milliseconds:.2f} ms", logger=logger.debug
    )
    def run(self, preds: torch.Tensor) -> List[Prediction]:
        """Post-processes the prediction tensor using argmax and returns a list of prediction data structures, one for each face.

        Args:
            preds (torch.Tensor): Batch prediction tensor.

        Returns:
            List[Prediction]: List of prediction data structures containing the predicted labelsand confidence scores for each face in the batch.
        """
        preds = torch.sigmoid(preds.squeeze(1))
        preds_thresh = preds.where(preds >= self.threshold, torch.zeros_like(preds))
        indices = torch.round(preds_thresh)
        indices = indices.cpu().numpy().astype(int).tolist()
        pred_list = self.create_pred_list(preds, indices)

        return pred_list

Ancestors

• BasePredPostProcessor
• BaseProcessor

Methods

def run(self, preds: torch.Tensor) ‑> List[Prediction]

Post-processes the prediction tensor using argmax and returns a list of prediction data structures, one for each face.

Args

preds : torch.Tensor

Batch prediction tensor.

Returns

List[Prediction]

List of prediction data structures containing the predicted labelsand confidence scores for each face in the batch.

Inherited members

• BasePredPostProcessor:
  • create_pred_list
  • optimize

class PostEmbedder (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str])

Initialize the predictor postprocessor that extracts the embedding from the prediction tensor and returns a list of prediction data structures.

Args

transform : Compose

Composed Torch transform object.

device : torch.device

Torch device cpu or cuda.

optimize_transform : bool

Whether to optimize the transform using TorchScript.

labels : List[str]

List of labels.

Expand source code

class PostEmbedder(BasePredPostProcessor):
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
    ):
        """Initialize the predictor postprocessor that extracts the embedding from the prediction tensor and returns a list of prediction data structures.

        Args:
            transform (Compose): Composed Torch transform object.
            device (torch.device): Torch device cpu or cuda.
            optimize_transform (bool): Whether to optimize the transform using TorchScript.
            labels (List[str]): List of labels.
        """
        super().__init__(transform, device, optimize_transform, labels)

    @Timer("PostEmbedder.run", "{name}: {milliseconds:.2f} ms", logger=logger.debug)
    def run(self, preds: torch.Tensor) -> List[Prediction]:
        """Extracts the embedding from the prediction tensor and returns a list of prediction data structures, one for each face.

        Args:
            preds (torch.Tensor): Batch prediction tensor.

        Returns:
            List[Prediction]: List of prediction data structures containing the predicted embeddings.
        """
        if isinstance(preds, tuple):
            preds = preds[0]

        indices = [0] * preds.shape[0]
        pred_list = self.create_pred_list(preds, indices)

        return pred_list

Ancestors

• BasePredPostProcessor
• BaseProcessor

Methods

def run(self, preds: torch.Tensor) ‑> List[Prediction]

Extracts the embedding from the prediction tensor and returns a list of prediction data structures, one for each face.

Args

preds : torch.Tensor

Batch prediction tensor.

Returns

List[Prediction]

List of prediction data structures containing the predicted embeddings.

Inherited members

• BasePredPostProcessor:
  • create_pred_list
  • optimize

class PostMultiLabel (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str], dim: int, threshold: float = 0.5)

Initialize the predictor postprocessor that extracts multiple labels from the confidence scores.

Args

transform : Compose

Composed Torch transform object.

device : torch.device

Torch device cpu or cuda.

optimize_transform : bool

Whether to optimize the transform using TorchScript.

labels : List[str]

List of labels.

dim : int

Axis along which to apply the softmax.

threshold : float

Probability threshold for including a label. Only labels with a confidence score above the threshold are included. Defaults to 0.5.

Expand source code

class PostMultiLabel(BasePredPostProcessor):
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
        dim: int,
        threshold: float = 0.5,
    ):
        """Initialize the predictor postprocessor that extracts multiple labels from the confidence scores.

        Args:
            transform (Compose): Composed Torch transform object.
            device (torch.device): Torch device cpu or cuda.
            optimize_transform (bool): Whether to optimize the transform using TorchScript.
            labels (List[str]): List of labels.
            dim (int): Axis along which to apply the softmax.
            threshold (float): Probability threshold for including a label. Only labels with a confidence score above the threshold are included. Defaults to 0.5.
        """
        super().__init__(transform, device, optimize_transform, labels)
        self.dim = dim
        self.threshold = threshold

    @Timer("PostMultiLabel.run", "{name}: {milliseconds:.2f} ms", logger=logger.debug)
    def run(self, preds: torch.Tensor) -> List[Prediction]:
        """Extracts multiple labels and puts them in other[multi] predictions. The most likely label is put in the label field. Confidence scores are returned in the logits field.

        Args:
            preds (torch.Tensor): Batch prediction tensor.

        Returns:
            List[Prediction]: List of prediction data structures containing the most prevailing label, confidence scores, and multiple labels for each face.
        """
        if isinstance(preds, tuple):
            preds = preds[0]

        indices = torch.argmax(preds, dim=self.dim).cpu().numpy().tolist()

        pred_list = []
        for i in range(preds.shape[0]):
            preds_sample = preds[i]
            label_filter = (preds_sample > self.threshold).cpu().numpy().tolist()
            labels_true = list(compress(self.labels, label_filter))
            pred = Prediction(
                label=self.labels[indices[i]],
                logits=preds_sample,
                other={"multi": labels_true},
            )
            pred_list.append(pred)

        return pred_list

Ancestors

• BasePredPostProcessor
• BaseProcessor

Methods

def run(self, preds: torch.Tensor) ‑> List[Prediction]

Extracts multiple labels and puts them in other[multi] predictions. The most likely label is put in the label field. Confidence scores are returned in the logits field.

Args

preds : torch.Tensor

Batch prediction tensor.

Returns

List[Prediction]

List of prediction data structures containing the most prevailing label, confidence scores, and multiple labels for each face.

Inherited members

• BasePredPostProcessor:
  • create_pred_list
  • optimize

class PostLabelConfidencePairs (transform: torchvision.transforms.transforms.Compose, device: torch.device, optimize_transform: bool, labels: List[str], offsets: Optional[List[float]] = None)

Initialize the predictor postprocessor that zips the confidence scores with the labels.

Args

transform : Compose

Composed Torch transform object.

device : torch.device

Torch device cpu or cuda.

optimize_transform : bool

Whether to optimize the transform using TorchScript.

labels : List[str]

List of labels.

offsets : Optional[List[float]], optional

List of offsets to add to the confidence scores. Defaults to None.

Expand source code

class PostLabelConfidencePairs(BasePredPostProcessor):
    def __init__(
        self,
        transform: transforms.Compose,
        device: torch.device,
        optimize_transform: bool,
        labels: List[str],
        offsets: Optional[List[float]] = None,
    ):
        """Initialize the predictor postprocessor that zips the confidence scores with the labels.

        Args:
            transform (Compose): Composed Torch transform object.
            device (torch.device): Torch device cpu or cuda.
            optimize_transform (bool): Whether to optimize the transform using TorchScript.
            labels (List[str]): List of labels.
            offsets (Optional[List[float]], optional): List of offsets to add to the confidence scores. Defaults to None.
        """
        super().__init__(transform, device, optimize_transform, labels)

        if offsets is None:
            offsets = [0] * len(labels)
        self.offsets = offsets

    @Timer(
        "PostLabelConfidencePairs.run",
        "{name}: {milliseconds:.2f} ms",
        logger=logger.debug,
    )
    def run(self, preds: torch.Tensor) -> List[Prediction]:
        """Extracts the confidence scores and puts them in other[label] predictions.

        Args:
            preds (torch.Tensor): Batch prediction tensor.

        Returns:
            List[Prediction]: List of prediction data structures containing the logits and label logit pairs.
        """
        if isinstance(preds, tuple):
            preds = preds[0]

        pred_list = []
        for i in range(preds.shape[0]):
            preds_sample = preds[i]
            preds_sample_list = preds_sample.cpu().numpy().tolist()
            other_labels = {
                label: preds_sample_list[j] + self.offsets[j]
                for j, label in enumerate(self.labels)
            }
            pred = Prediction(
                label="other",
                logits=preds_sample,
                other=other_labels,
            )
            pred_list.append(pred)

        return pred_list

Ancestors

• BasePredPostProcessor
• BaseProcessor

Methods

def run(self, preds: torch.Tensor) ‑> List[Prediction]

Extracts the confidence scores and puts them in other[label] predictions.

Args

preds : torch.Tensor

Batch prediction tensor.

Returns

List[Prediction]

List of prediction data structures containing the logits and label logit pairs.

Inherited members

• BasePredPostProcessor:
  • create_pred_list
  • optimize