quadra 0.0.1__py3-none-any.whl → 2.2.7__py3-none-any.whl

quadra/losses/ssl/hyperspherical.py

@@ -0,0 +1,45 @@
+import torch
+from torch.nn.functional import cosine_similarity
+
+
+def cosine_align_loss(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    """Computes mean of cosine distance based on similarity mean(1 - cosine_similarity).
+
+    Args:
+        x: feature n1
+        y: feature n2.
+
+    Returns:
+        cosine align loss
+    """
+    cos = 1 - cosine_similarity(x, y, dim=1)
+    return torch.mean(cos)
+
+
+# Source: https://arxiv.org/pdf/2005.10242.pdf
+def align_loss(x: torch.Tensor, y: torch.Tensor, alpha: int = 2) -> torch.Tensor:
+    """Mean(l2^alpha).
+
+    Args:
+        x: feature n1
+        y: feature n2
+        alpha: pow of the norm loss.
+
+    Returns:
+        Align loss
+    """
+    norm = torch.norm(x - y, p=2, dim=1)
+    return torch.mean(torch.pow(norm, alpha))
+
+
+def uniform_loss(x: torch.Tensor, t: float = 2.0) -> torch.Tensor:
+    """log(mean(exp(-t*dist_p2))).
+
+    Args:
+        x: feature tensor
+        t: temperature of the dist_p2.
+
+    Returns:
+        Uniform loss
+    """
+    return torch.log(torch.mean(torch.exp(torch.pow(torch.pdist(x, p=2), 2) * -t)))

quadra/losses/ssl/idmm.py

@@ -0,0 +1,50 @@
+import torch
+import torch.nn.functional as F
+
+
+def idmm_loss(
+    p1: torch.Tensor,
+    y1: torch.Tensor,
+    smoothing: float = 0.1,
+) -> torch.Tensor:
+    """IDMM loss described in https://arxiv.org/abs/2201.10728.
+
+    Args:
+        p1: Prediction labels for `z1`
+        y1: Instance labels for `z1`
+        smoothing: smoothing factor used for label smoothing.
+            Defaults to 0.1.
+
+    Returns:
+        IDMM loss
+    """
+    loss = F.cross_entropy(p1, y1, label_smoothing=smoothing)
+    return loss
+
+
+class IDMMLoss(torch.nn.Module):
+    """IDMM loss described in https://arxiv.org/abs/2201.10728."""
+
+    def __init__(self, smoothing: float = 0.1):
+        super().__init__()
+        self.smoothing = smoothing
+
+    def forward(
+        self,
+        p1: torch.Tensor,
+        y1: torch.Tensor,
+    ) -> torch.Tensor:
+        """IDMM loss described in https://arxiv.org/abs/2201.10728.
+
+        Args:
+            p1: Prediction labels for `z1`
+            y1: Instance labels for `z1`
+
+        Returns:
+            IDMM loss
+        """
+        return idmm_loss(
+            p1,
+            y1,
+            self.smoothing,
+        )

quadra/losses/ssl/simclr.py

@@ -0,0 +1,67 @@
+import math
+
+import torch
+import torch.nn.functional as F
+
+from quadra.utils.utils import AllGatherSyncFunction
+
+
+def simclr_loss(
+    features1: torch.Tensor,
+    features2: torch.Tensor,
+    temperature: float = 1.0,
+) -> torch.Tensor:
+    """SimCLR loss described in https://arxiv.org/pdf/2002.05709.pdf.
+
+    Args:
+        temperature: optional temperature
+        features1: First augmented features (i.e. T(features))
+        features2: Second augmented features (i.e. T'(features))
+
+    Returns:
+        SimCLR loss
+    """
+    features1 = F.normalize(features1, dim=-1)
+    features2 = F.normalize(features2, dim=-1)
+    if torch.distributed.is_available() and torch.distributed.is_initialized():
+        features1_dist = AllGatherSyncFunction.apply(features1)
+        features2_dist = AllGatherSyncFunction.apply(features2)
+    else:
+        features1_dist = features1
+        features2_dist = features2
+    features = torch.cat([features1, features2], dim=0)  # [2B, d]
+    features_dist = torch.cat([features1_dist, features2_dist], dim=0)  # [2B * DIST_SIZE, d]
+
+    # Similarity matrix
+    sim = torch.exp(torch.div(torch.mm(features, features_dist.t()), temperature))  # [2B, 2B * DIST_SIZE]
+
+    # Negatives
+    neg = sim.sum(dim=-1)
+
+    # From each row, subtract e^(1/temp) to remove similarity measure for zi * zi, since
+    # (zi^T * zi) / ||zi||^2 = 1
+    row_sub = torch.full_like(neg, math.e ** (1 / temperature), device=neg.device)
+    neg = torch.clamp(neg - row_sub, min=1e-6)  # clamp for numerical stability
+
+    # Positive similarity, pos becomes [2 * batch_size]
+    pos = torch.exp(torch.div(torch.sum(features1 * features2, dim=-1), temperature))
+    pos = torch.cat([pos, pos], dim=0)
+
+    loss = -torch.log(pos / (neg + 1e-6)).mean()
+    return loss
+
+
+class SimCLRLoss(torch.nn.Module):
+    """SIMCLRloss module.
+
+    Args:
+        temperature: temperature of SIM loss.
+    """
+
+    def __init__(self, temperature: float = 1.0):
+        super().__init__()
+        self.temperature = temperature
+
+    def forward(self, x1: torch.Tensor, x2: torch.Tensor) -> torch.Tensor:
+        """Forward pass of the loss."""
+        return simclr_loss(x1, x2, temperature=self.temperature)

quadra/losses/ssl/simsiam.py

@@ -0,0 +1,30 @@
+import torch
+import torch.nn.functional as F
+
+
+def simsiam_loss(
+    p1: torch.Tensor,
+    p2: torch.Tensor,
+    z1: torch.Tensor,
+    z2: torch.Tensor,
+) -> torch.Tensor:
+    """SimSIAM loss described in https://arxiv.org/abs/2011.10566.
+
+    Args:
+        p1: First `predicted` features (i.e. h(f(T(x1))))
+        p2: Second `predicted` features (i.e. h(f(T'(x2))))
+        z1: First 'projected features (i.e. f(T(x1)))
+        z2: Second 'projected features (i.e. f(T(x2)))
+
+    Returns:
+        SimSIAM loss
+    """
+    return -(F.cosine_similarity(p1, z2).mean() + F.cosine_similarity(p2, z1).mean()) * 0.5
+
+
+class SimSIAMLoss(torch.nn.Module):
+    """SimSIAM loss module."""
+
+    def forward(self, p1: torch.Tensor, p2: torch.Tensor, z1: torch.Tensor, z2: torch.Tensor) -> torch.Tensor:
+        """Compute the SimSIAM loss."""
+        return simsiam_loss(p1, p2, z1, z2)

quadra/losses/ssl/vicreg.py

@@ -0,0 +1,76 @@
+import torch
+
+
+def vicreg_loss(
+    z1: torch.Tensor,
+    z2: torch.Tensor,
+    lambd: float,
+    mu: float,
+    nu: float = 1,
+    gamma: float = 1,
+) -> torch.Tensor:
+    """VICReg loss described in https://arxiv.org/abs/2105.04906.
+
+    Args:
+        z1: First `augmented` normalized features (i.e. f(T(x))). The normalization can be obtained with
+            z1_norm = (z1 - z1.mean(0)) / z1.std(0)
+        z2: Second `augmented` normalized features (i.e. f(T(x))). The normalization can be obtained with
+            z2_norm = (z2 - z2.mean(0)) / z2.std(0)
+        lambd: lambda multiplier for redundancy term.
+        mu: mu multiplier for similarity term.
+        nu: nu multiplier for variance term. Default: 1
+        gamma: gamma multiplier for covariance term. Default: 1
+
+    Returns:
+        VICReg loss
+    """
+    # Variance loss
+    std_z1 = torch.sqrt(z1.var(dim=0) + 0.0001)
+    std_z2 = torch.sqrt(z2.var(dim=0) + 0.0001)
+    v_z1 = torch.nn.functional.relu(gamma - std_z1).mean()
+    v_z2 = torch.nn.functional.relu(gamma - std_z2).mean()
+    var_loss = v_z1 + v_z2
+
+    # Similarity loss
+    sim_loss = torch.nn.functional.mse_loss(z1, z2)
+
+    # Covariance loss
+    n = z1.size(0)
+    d = z1.size(1)
+    z1 = z1 - z1.mean(dim=0)
+    z2 = z2 - z2.mean(dim=0)
+    cov_z1 = (z1.T @ z1) / (n - 1)
+    cov_z2 = (z2.T @ z2) / (n - 1)
+    off_diagonal_cov_z1 = cov_z1.flatten()[:-1].view(d - 1, d + 1)[:, 1:].flatten()
+    off_diagonal_cov_z2 = cov_z2.flatten()[:-1].view(d - 1, d + 1)[:, 1:].flatten()
+    cov_loss = off_diagonal_cov_z1.pow_(2).sum() / d + off_diagonal_cov_z2.pow_(2).sum() / d
+
+    return lambd * sim_loss + mu * var_loss + nu * cov_loss
+
+
+class VICRegLoss(torch.nn.Module):
+    """VIC regression loss module.
+
+    Args:
+        lambd: lambda multiplier for redundancy term.
+        mu: mu multiplier for similarity term.
+        nu: nu multiplier for variance term. Default: 1.
+        gamma: gamma multiplier for covariance term. Default: 1.
+    """
+
+    def __init__(
+        self,
+        lambd: float,
+        mu: float,
+        nu: float = 1,
+        gamma: float = 1,
+    ):
+        super().__init__()
+        self.lambd = lambd
+        self.mu = mu
+        self.nu = nu
+        self.gamma = gamma
+
+    def forward(self, z1: torch.Tensor, z2: torch.Tensor) -> torch.Tensor:
+        """Computes VICReg loss."""
+        return vicreg_loss(z1, z2, self.lambd, self.mu, self.nu, self.gamma)

quadra/main.py

@@ -0,0 +1,49 @@
+import time
+
+import hydra
+import matplotlib
+from omegaconf import DictConfig
+from pytorch_lightning import seed_everything
+
+from quadra.tasks.base import Task
+from quadra.utils.resolver import register_resolvers
+from quadra.utils.utils import get_logger, load_envs, setup_opencv
+from quadra.utils.validator import validate_config
+
+load_envs()
+register_resolvers()
+
+
+matplotlib.use("Agg")
+log = get_logger(__name__)
+
+
+@hydra.main(config_path="configs/", config_name="config.yaml", version_base="1.3.0")
+def main(config: DictConfig):
+    """Main entry function for any of the tasks."""
+    if config.validate:
+        start = time.time()
+        validate_config(config)
+        stop = time.time()
+        log.info("Config validation took %f seconds", stop - start)
+
+    from quadra.utils import utils  # pylint: disable=import-outside-toplevel
+
+    utils.extras(config)
+
+    # Prints the resolved configuration to the console
+    if config.get("print_config"):
+        utils.print_config(config, resolve=True)
+
+    # Set seed for random number generators in pytorch, numpy and python.random
+    seed_everything(config.core.seed, workers=True)
+    setup_opencv()
+
+    # Run specified task using the configuration composition
+    task: Task = hydra.utils.instantiate(config.task, config, _recursive_=False)
+    task.execute()
+
+
+if __name__ == "__main__":
+    # pylint: disable=no-value-for-parameter
+    main()

quadra/metrics/__init__.py

@@ -0,0 +1,3 @@
+from .segmentation import segmentation_props
+
+__all__ = ["segmentation_props"]

quadra/metrics/segmentation.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+from typing import cast
+
+import numpy as np
+import torch
+from scipy.optimize import linear_sum_assignment
+from skimage.measure import label, regionprops  # pylint: disable=no-name-in-module
+
+from quadra.utils.evaluation import dice
+
+
+def _pad_to_shape(a: np.ndarray, shape: tuple, constant_values: int = 0) -> np.ndarray:
+    """Pad lower - right with 0s
+    Args:
+        a: numpy array to pad
+        shape: shape of the resulting np.array
+        constant_values: value to pad.
+
+    Returns:
+        Padded array
+    """
+    y_, x_ = shape
+    y, x = a.shape
+    y_pad = y_ - y
+    x_pad = x_ - x
+    return np.pad(
+        a,
+        (
+            (0, y_pad),
+            (0, x_pad),
+        ),
+        mode="constant",
+        constant_values=constant_values,
+    )
+
+
+def _get_iou(bboxes1: np.ndarray, bboxes2: np.ndarray, approx_iou: bool = False) -> np.ndarray:
+    """Intersect over union
+    Args:
+        bboxes1: extracted bounding boxes
+        bboxes2: ground truth
+        approx_iou: flag to approximate.
+
+    Returns:
+        Intersect over union array
+    """
+    x11, y11, x12, y12 = np.split(bboxes1, 4, axis=1)
+    x21, y21, x22, y22 = np.split(bboxes2, 4, axis=1)
+
+    # determine the (x, y)-coordinates of the intersection rectangle
+    xA = np.maximum(x11, x21.T)
+    yA = np.maximum(y11, y21.T)
+    xB = np.minimum(x12, x22.T)
+    yB = np.minimum(y12, y22.T)
+
+    # compute the area of intersection rectangle
+    inter_area = np.maximum((xB - xA), 0) * np.maximum((yB - yA), 0)
+
+    # compute the area of both the prediction and ground-truth rectangles
+    box_a_area = (x12 - x11) * (y12 - y11)
+    box_b_area = (x22 - x21) * (y22 - y21)
+
+    if approx_iou:
+        iou = inter_area / box_b_area.T
+    else:
+        iou = inter_area / (box_a_area + box_b_area.T - inter_area)
+
+    return iou
+
+
+def _get_dice_matrix(
+    labels_pred: np.ndarray,
+    n_labels_pred: int,
+    labels_gt: np.ndarray,
+    n_labels_gt: int,
+) -> np.ndarray:
+    """Create dice matrix
+    Args:
+        labels_pred: predicted label
+        n_labels_pred: number of label predicted
+        labels_gt: ground truth labels
+        n_labels_gt: number of gt labels.
+
+    Returns:
+        Dice matrix
+    """
+    m = np.zeros((n_labels_pred, n_labels_gt))
+    for i in range(n_labels_pred):
+        pred = labels_pred == i + 1
+        for j in range(n_labels_gt):
+            gt = labels_gt == j + 1
+            m[i, j] = dice(
+                torch.Tensor(pred).unsqueeze(0).unsqueeze(0),
+                torch.Tensor(gt).unsqueeze(0).unsqueeze(0),
+                reduction="none",
+            )
+    return m
+
+
+def segmentation_props(
+    pred: np.ndarray, mask: np.ndarray
+) -> tuple[float, float, float, float, list[float], float, int, int, int, int]:
+    """Return some information regarding a segmentation task.
+
+    Args:
+        pred (np.ndarray[bool]): Prediction of a segmentation model as
+            a binary image.
+        mask (np.ndarray[bool]): Ground truth mask as binary image
+
+    Returns:
+        1-Dice(pred, mask) Given a matrix (a_ij) = (1-Dice)(prediction_i, ground_truth_j),
+            where prediction_i is the i-th prediction connected component and
+            ground_truth_j is the j-th ground truth connected component,
+            I compute the LSA (Linear Sum Assignment) to find the optimal 1-to-1 assignment
+            between predictions and ground truths that minimize the (1-Dice) score.
+            Then, for every unique pair of (predictioni, ground_truthj) we compute Average
+             (1-Dice)(predictioni, ground_truthj)
+        Average (1-Dice)(predictioni, ground_truthj) between True Positives
+            (that is predictions associated to a ground truth), which is gratis from a[i,j],
+            where the average is computed w.r.t. the total number of True Positives found.
+        Average IoU(predictioni, ground_truthj) between True Positives
+            (that is predictions associated to a ground truth),
+            where the average is computed w.r.t. the total number of True Positives found.
+            The IoU is computed between the minimum enclosing bounding box
+            of a prediction and a ground truth.
+        Average area of False Positives
+        Histogram of false positives
+        Average area of False Negatives
+        Number of True Positives (predictions associated to a ground truth)
+        Number of False Positives (predictions without a ground truth associated)
+                and their avg. area (avg is taken w.r.t. the total number of False Positives found)
+        Number of False Negatives (ground truth without a predictions associated)
+            and their avg. area (avg is taken w.r.t. the total number of False Negatives found)
+        Number of labels in the mask.
+    """
+    labels_pred, n_labels_pred = label(pred, connectivity=2, return_num=True, background=0)
+    labels_mask, n_labels_mask = label(mask, connectivity=2, return_num=True, background=0)
+
+    labels_pred = cast(np.ndarray, labels_pred)
+    labels_mask = cast(np.ndarray, labels_mask)
+    n_labels_pred = cast(int, n_labels_pred)
+    n_labels_mask = cast(int, n_labels_mask)
+
+    props_pred = regionprops(labels_pred)
+    props_mask = regionprops(labels_mask)
+    pred_bbox = np.array([props_pred[i].bbox for i in range(len(props_pred))])
+    mask_bbox = np.array([props_mask[i].bbox for i in range(len(props_mask))])
+
+    global_dice = float(
+        dice(
+            torch.Tensor(pred).unsqueeze(0).unsqueeze(0),
+            torch.Tensor(mask).unsqueeze(0).unsqueeze(0),
+        ).item()
+    )
+    lsa_iou = 0.0
+    lsa_dice = 0.0
+    tp_num = 0
+    fp_num = 0
+    fn_num = 0
+    fp_area = 0.0
+    fn_area = 0.0
+    fp_hist: list[float] = []
+    if n_labels_pred > 0 and n_labels_mask > 0:
+        dice_mat = _get_dice_matrix(labels_pred, n_labels_pred, labels_mask, n_labels_mask)
+        # Thresholding over Dice scores
+        dice_mat = np.where(dice_mat <= 0.9, dice_mat, 1.0)
+        iou_mat = _get_iou(pred_bbox, mask_bbox, approx_iou=False)
+        dice_mat_shape = dice_mat.shape
+        max_dim = np.max(dice_mat_shape)
+        # Add dummy Dices so LSA is unique and i can compute FP and FN
+        dice_mat = _pad_to_shape(dice_mat, (max_dim, max_dim), 1)
+        lsa = linear_sum_assignment(dice_mat, maximize=False)
+        for row, col in zip(lsa[0], lsa[1]):
+            # More preds than GTs --> False Positive
+            if row < n_labels_pred and col >= n_labels_mask:
+                min_row = pred_bbox[row][0]
+                min_col = pred_bbox[row][1]
+                h = pred_bbox[row][2] - min_row
+                w = pred_bbox[row][3] - min_col
+                fp_num += 1
+                area = pred[min_row : min_row + h, min_col : min_col + w].sum()
+                fp_area += area
+                fp_hist.append(area)
+                continue
+
+            # More GTs than preds --> False Negative
+            if col < n_labels_mask and row >= n_labels_pred:
+                min_row = mask_bbox[col][0]
+                min_col = mask_bbox[col][1]
+                h = mask_bbox[col][2] - min_row
+                w = mask_bbox[col][3] - min_col
+                fn_num += 1
+                fn_area += mask[min_row : min_row + h, min_col : min_col + w].sum()
+                continue
+
+            # Real True Positive: a prediction has been assigned to a gt
+            # with at least a 1-Dice score of 0.9
+            if dice_mat[row, col] <= 0.9:
+                tp_num += 1
+                lsa_iou += iou_mat[row, col]
+                lsa_dice += dice_mat[row, col]
+            else:
+                # Here we have both a FP and a FN
+                min_row = pred_bbox[row][0]
+                min_col = pred_bbox[row][1]
+                h = pred_bbox[row][2] - min_row
+                w = pred_bbox[row][3] - min_col
+                fp_num += 1
+                area = pred[min_row : min_row + h, min_col : min_col + w].sum()
+                fp_area += area
+                fp_hist.append(area)
+
+                min_row = mask_bbox[col][0]
+                min_col = mask_bbox[col][1]
+                h = mask_bbox[col][2] - min_row
+                w = mask_bbox[col][3] - min_col
+                fn_num += 1
+                fn_area += mask[min_row : min_row + h, min_col : min_col + w].sum()
+    elif len(pred_bbox) > 0 and len(mask_bbox) == 0:  # No GTs --> FP
+        for p_bbox in pred_bbox:
+            min_row = p_bbox[0]
+            min_col = p_bbox[1]
+            h = p_bbox[2] - min_row
+            w = p_bbox[3] - min_col
+            fp_num += 1
+            # print("FP area:", pred[min_row : min_row + h, min_col : min_col + w].sum())
+            area = pred[min_row : min_row + h, min_col : min_col + w].sum()
+            fp_area += area
+            fp_hist.append(area)
+    elif len(pred_bbox) == 0 and len(mask_bbox) > 0:  # No preds --> FN
+        for m_bbox in mask_bbox:
+            min_row = m_bbox[0]
+            min_col = m_bbox[1]
+            h = m_bbox[2] - min_row
+            w = m_bbox[3] - min_col
+            fn_num += 1
+            # print("FN area:", mask[min_row : min_row + h, min_col : min_col + w].sum())
+            fn_area += mask[min_row : min_row + h, min_col : min_col + w].sum()
+    return (
+        global_dice,
+        lsa_dice,
+        lsa_iou,
+        fp_area,
+        fp_hist,
+        fn_area,
+        tp_num,
+        fp_num,
+        fn_num,
+        n_labels_mask,
+    )