confusion_matrix/confusion_matrix.py

import torch
import numpy as np

import pandas as pd
import seaborn as sn
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
from itertools import product
from matplotlib.collections import QuadMesh
from scipy.spatial.distance import cdist
from matplotlib.figure import Figure
from numpy.typing import NDArray, ArrayLike


def get_new_fig(fn, figsize=[9, 9]):
    """Init graphics"""
    fig1 = plt.figure(fn, figsize)
    ax1 = fig1.gca()  # Get Current Axis
    ax1.cla()  # clear existing plot
    return fig1, ax1


def configcell_text_and_colors(array_df, lin, col, oText, facecolors, posi, fz, fmt, show_null_values=False):
    """
    config cell text and colors
    and return text elements to add and to dell
    @TODO: use fmt
    """
    text_add = []
    text_del = []
    cell_val = array_df[lin][col]
    tot_all = array_df[-1][-1]
    per = (float(cell_val) / tot_all) * 100
    curr_column = array_df[:, col]
    ccl = len(curr_column)

    # last line  and/or last column
    if (col == (ccl - 1)) or (lin == (ccl - 1)):
        # tots and percents
        if cell_val != 0:
            if (col == ccl - 1) and (lin == ccl - 1):
                tot_rig = 0
                for i in range(array_df.shape[0] - 1):
                    tot_rig += array_df[i][i]
                per_ok = (float(tot_rig) / cell_val) * 100
            elif col == ccl - 1:
                tot_rig = array_df[lin][lin]
                per_ok = (float(tot_rig) / cell_val) * 100
            elif lin == ccl - 1:
                tot_rig = array_df[col][col]
                per_ok = (float(tot_rig) / cell_val) * 100
            per_err = 100 - per_ok  # type: ignore
        else:
            per_ok = per_err = 0

        per_ok_s = ["%.2f%%" % (per_ok), "100%"][per_ok == 100]  # type: ignore

        # text to DEL
        text_del.append(oText)

        # text to ADD
        font_prop = fm.FontProperties(weight="bold", size=fz)
        text_kwargs = dict(
            color="w",
            ha="center",
            va="center",
            gid="sum",
            fontproperties=font_prop,
        )
        lis_txt = ["%d" % (cell_val), per_ok_s, "%.2f%%" % (per_err)]
        lis_kwa = [text_kwargs]
        dic = text_kwargs.copy()
        dic["color"] = "g"
        lis_kwa.append(dic)
        dic = text_kwargs.copy()
        dic["color"] = "r"
        lis_kwa.append(dic)
        lis_pos = [
            (oText._x, oText._y - 0.3),
            (oText._x, oText._y),
            (oText._x, oText._y + 0.3),
        ]
        for i in range(len(lis_txt)):
            newText = dict(
                x=lis_pos[i][0],
                y=lis_pos[i][1],
                text=lis_txt[i],
                kw=lis_kwa[i],
            )
            text_add.append(newText)

        # set background color for sum cells (last line and last column)
        carr = [0.27, 0.30, 0.27, 1.0]
        if (col == ccl - 1) and (lin == ccl - 1):
            carr = [0.17, 0.20, 0.17, 1.0]
        facecolors[posi] = carr

    else:
        if per > 0:
            txt = "%s\n%.1f%%" % (cell_val, per)
        else:
            if show_null_values == False:
                txt = ""
            elif show_null_values == True:
                txt = "0"
            else:
                txt = "0\n0.0%"
        oText.set_text(txt)

        # main diagonal
        if col == lin:
            # set color of the textin the diagonal to white
            oText.set_color("w")
            # set background color in the diagonal to blue
            facecolors[posi] = [0.35, 0.8, 0.55, 1.0]
        else:
            oText.set_color("r")

    return text_add, text_del


def insert_totals(df_cm):
    """insert total column and line (the last ones)"""
    sum_col = []
    for c in df_cm.columns:
        sum_col.append(df_cm[c].sum())
    sum_lin = []
    for item_line in df_cm.iterrows():
        sum_lin.append(item_line[1].sum())
    df_cm["sum_lin"] = sum_lin
    sum_col.append(np.sum(sum_lin))
    df_cm.loc["sum_col"] = sum_col


def pp_matrix(
    df_cm: NDArray[np.float64] | pd.DataFrame,
    annot=True,
    cmap="viridis",
    fmt=".2f",
    fz=10,
    lw=1,
    cbar=False,
    figsize=[9, 9],
    show_null_values=False,
    pred_val_axis="x",
    show=False,
    rotation=True,
    display_labels=None,
):
    """
    print conf matrix with default layout (like matlab)
    params:
      df_cm          dataframe (pandas) without totals
      annot          print text in each cell
      cmap           Oranges,Oranges_r,YlGnBu,Blues,RdBu, ... see:
      fz             fontsize
      lw             linewidth
      pred_val_axis  where to show the prediction values (x or y axis)
                      'col' or 'x': show predicted values in columns (x axis) instead lines
                      'lin' or 'y': show predicted values in lines   (y axis)
      show           show the plot or not
      rotation       rotate or not labels on figure
      display_labels None, list of labels that display on figure
    """
    if not isinstance(df_cm, pd.DataFrame):
        df_cm = pd.DataFrame(df_cm, index=display_labels, columns=display_labels)

    if pred_val_axis in ("col", "x"):
        xlbl = "Predicted"
        ylbl = "Actual"
    else:
        xlbl = "Actual"
        ylbl = "Predicted"
        df_cm = df_cm.T

    # create "Total" column
    insert_totals(df_cm)

    # this is for print allways in the same window
    fig, ax1 = get_new_fig("Conf matrix default", figsize)

    ax = sn.heatmap(
        df_cm,
        annot=annot,
        annot_kws={"size": fz},
        linewidths=lw,
        ax=ax1,
        cbar=cbar,
        cmap=cmap,
        linecolor="w",
        fmt=fmt,
    )

    # set ticklabels rotation
    if rotation:
        rotation_x = 45
        rotation_y = 25
    else:
        rotation_x = 0
        rotation_y = 90

    ax.set_xticklabels(ax.get_xticklabels(), rotation=rotation_y, fontsize=10)
    ax.set_yticklabels(ax.get_yticklabels(), rotation=rotation_x, fontsize=10)

    # Turn off all the ticks
    for t in ax.xaxis.get_major_ticks():
        t.tick1On = False
        t.tick2On = False
    for t in ax.yaxis.get_major_ticks():
        t.tick1On = False
        t.tick2On = False

    # face colors list
    quadmesh = ax.findobj(QuadMesh)[0]
    facecolors = quadmesh.get_facecolors()

    # iter in text elements
    array_df = np.array(df_cm.to_records(index=False).tolist())
    text_add = []
    text_del = []
    posi = -1  # from left to right, bottom to top.
    for t in ax.collections[0].axes.texts:  # ax.texts:
        pos = np.array(t.get_position()) - [0.5, 0.5]
        lin = int(pos[1])
        col = int(pos[0])
        posi += 1

        # set text
        txt_res = configcell_text_and_colors(array_df, lin, col, t, facecolors, posi, fz, fmt, show_null_values)

        text_add.extend(txt_res[0])
        text_del.extend(txt_res[1])

    # remove the old ones
    for item in text_del:
        item.remove()
    # append the new ones
    for item in text_add:
        ax.text(item["x"], item["y"], item["text"], **item["kw"])

    # titles and legends
    ax.set_title("Confusion matrix")
    ax.set_xlabel(xlbl)
    ax.set_ylabel(ylbl)
    # set layout slim
    plt.tight_layout()
    if show:
        plt.show()

    return plt.gcf()


class ConfusionMatrix:
    def __init__(self, thrs_config: dict, class_names: dict, iou_thr=0.5,):
        """
        Class to create and dislpay confusion matrix for MaskRCNN
        or any type of instance segmentation and detection architectures

        Parameters
        ----------
            - iou_thr: IOU threshold
            - thrs_config: dict of thresholds for every class
            - class_names: dict of class names accordingly to class numbers

        Attributes
        ----------
            - box_matrix: confusion matrix that contains results from boxes
            - mask_matrix: confusion matrix that contains results from masks
            - display_labels: labels according to classes + miss
            - figure_: contains last plot of confusion matrix

        Examples
        --------
        >>> from confusion_matrix import MaskRcnnConfusionMatrix

        >>> confusion_matrix = MaskRcnnConfusionMatrix(class_names={0: 'class1', 1: 'class2'},
        ...                                            thrs_config={0: 0.5, 1: 0.5})
        >>> for images, targets in test_dataloader:
        >>>     outputs = model(images)
        >>>     confusion_matrix.update(outputs, targets)

        >>> confusion_matrix.plot(show=True)

        """
        self.iou_thr = iou_thr
        self.num_classes = len(thrs_config)
        self.classes = class_names.values()
        self.box_matrix = np.zeros((self.num_classes + 1, self.num_classes + 1))
        self.mask_matrix = np.zeros((self.num_classes + 1, self.num_classes + 1))
        self.thrs_config = thrs_config
        self.display_labels = list(self.classes) + ["Miss"]

    def update(self, predictions: dict, targets: dict, after_nms=False):
        """
        Update confusion matrix for masks and boxes.
        It is not very performative and effective implementations.
        Needs to be rewritten in vectorize style, cause currently it's loops
        Arguments:
        ---------
            predictions: dict of prediction from mask_rcnn
            targets: dict of targets from dataloader
            after_nms: it is after nms already or it needs to be thresholded here
        Returns:
        -------
            None, updates confusion matrix accordingly
        """
        if isinstance(targets["labels"], torch.Tensor):
            targets = {k: v.to("cpu").numpy() for k, v in targets.items() if type(v) is not str}
        l_classes = targets["labels"]
        l_bboxs = targets["boxes"]
        l_masks = targets["masks"]
        d_confs = predictions["scores"]
        d_bboxs = predictions["boxes"]
        d_masks = predictions["masks"]
        d_classes = predictions["labels"]
        if not after_nms:
            box_thrs = [self.thrs_config[label_id]["box_thr"] for label_id in d_classes]
            mask_thrs = [self.thrs_config[label_id]["mask_thr"] for label_id in d_classes]
            ids = np.where(d_confs > box_thrs)[0]
            d_classes = d_classes[ids]
            d_bboxs = d_bboxs[ids]
            d_masks = d_masks[ids]
        box_labels_detected = np.zeros(len(l_classes))
        mask_labels_detected = np.zeros(len(l_classes))
        box_detections_matched = np.zeros(len(d_classes))
        mask_detections_matched = np.zeros(len(d_classes))
        for l_idx, (l_class, l_bbox, l_mask) in enumerate(zip(l_classes, l_bboxs, l_masks)):
            for d_idx, (d_class, d_bbox, d_mask) in enumerate(zip(d_classes, d_bboxs, d_masks)):
                box_iou = self.box_pairwise_iou(l_bbox, d_bbox)
                mask_iou = self.mask_iou((l_mask, l_class), (d_mask, d_class))
                if box_iou >= self.iou_thr:
                    self.box_matrix[l_class, d_class] += 1
                    box_labels_detected[l_idx] = 1
                    box_detections_matched[d_idx] = 1
                if mask_iou >= self.iou_thr:
                    self.mask_matrix[l_class, d_class] += 1
                    mask_labels_detected[l_idx] = 1
                    mask_detections_matched[d_idx] = 1
        for i in np.where(box_labels_detected == 0)[0]:
            self.box_matrix[l_classes[i], -1] += 1
        for i in np.where(box_detections_matched == 0)[0]:
            self.box_matrix[-1, d_classes[i]] += 1
        for i in np.where(mask_labels_detected == 0)[0]:
            self.mask_matrix[l_classes[i], -1] += 1
        for i in np.where(mask_detections_matched == 0)[0]:
            self.mask_matrix[-1, d_classes[i]] += 1

    def process_batch(self, predictions: dict, targets: dict, after_nms=True):
        """
        Process batch of predictons and targets from model and dataloader
        to update confusion matrix.
        This is supposed to be effective vectorized implementations. Half of that have done, but not masks.
        It means that this implementation only for boxes confusion matrix

        Arguments:
            predictions: dict of prediction from mask_rcnn
            targets: dict of targets from dataloader
            after_nms: it is after nms already or it needs to be thresholded here
        Returns:
            None, updates confusion matrix accordingly
        """
        if isinstance(targets["labels"], torch.Tensor):
            targets = {k: v.to("cpu").numpy() for k, v in targets.items() if type(v) is not str}

        gt_classes = targets["labels"]
        box_thrs = [self.thrs_config[label_id]["box_thr"] for label_id in predictions["labels"]]
        try:
            prediction_indexes = np.where(predictions["scores"] > box_thrs)[0]
            prediction_classes = predictions["labels"][prediction_indexes]
        except IndexError or TypeError as e:
            # detections are empty, end of process
            print("Какая то хуйня произошла!")
            raise e
        if len(prediction_classes) == 0 and len(gt_classes) > 0:
            for gt_class in gt_classes:
                self.box_matrix[self.num_classes, gt_class] += 1
            return
        elif len(prediction_classes) == 0 and len(gt_classes) == 0:
            return

        all_ious = self.box_pairwise_iou(targets["boxes"], predictions["boxes"])
        want_idx = np.where(all_ious > self.iou_thr)

        all_matches = [
            [want_idx[0][i], want_idx[1][i], all_ious[want_idx[0][i], want_idx[1][i]]]
            for i in range(want_idx[0].shape[0])
        ]

        all_matches = np.array(all_matches)
        if all_matches.shape[0] > 0:  # if there is match
            all_matches = all_matches[all_matches[:, 2].argsort()[::-1]]
            all_matches = all_matches[np.unique(all_matches[:, 1], return_index=True)[1]]
            all_matches = all_matches[all_matches[:, 2].argsort()[::-1]]
            all_matches = all_matches[np.unique(all_matches[:, 0], return_index=True)[1]]

        for i, gt_class in enumerate(gt_classes):
            if all_matches.shape[0] > 0 and all_matches[all_matches[:, 0] == i].shape[0] == 1:
                detection_class = prediction_classes[int(all_matches[all_matches[:, 0] == i, 1][0])]
                self.box_matrix[detection_class, gt_class] += 1
            else:
                self.box_matrix[self.num_classes, gt_class] += 1

        for i, detection_class in enumerate(prediction_classes):
            if not all_matches.shape[0] or (all_matches.shape[0] and all_matches[all_matches[:, 1] == i].shape[0] == 0):
                detection_class = prediction_classes[i]
                self.box_matrix[detection_class, self.num_classes] += 1

    def box_pairwise_iou(self, boxes1: NDArray[np.float32], boxes2: NDArray[np.float32]) -> NDArray[np.float32]:
        # https://github.com/pytorch/vision/blob/master/torchvision/ops/boxes.py
        """
        Return intersection-over-union (Jaccard index) of boxes.
        Both sets of boxes are expected to be in (x1, y1, x2, y2) format.
        Arguments:
            boxes1 (Array[N, 4])
            boxes2 (Array[M, 4])
        Returns:
            iou (Array[N, M]): the NxM matrix containing the pairwise
                IoU values for every element in boxes1 and boxes2
        This implementation is taken from the above link and changed so that it only uses numpy..
        """
        if len(boxes1.shape) < 2:
            boxes1 = boxes1.reshape(1, -1)
        if len(boxes2.shape) < 2:
            boxes2 = boxes2.reshape(1, -1)

        def box_area(box):
            # box = 4xn
            return (box[2] - box[0]) * (box[3] - box[1])

        area1 = box_area(boxes1.T)
        area2 = box_area(boxes2.T)

        lt = np.maximum(boxes1[:, None, :2], boxes2[:, :2])  # [N,M,2]
        rb = np.minimum(boxes1[:, None, 2:], boxes2[:, 2:])  # [N,M,2]

        inter = np.prod(np.clip(rb - lt, a_min=0, a_max=None), 2)  # type: ignore
        return inter / (area1[:, None] + area2 - inter)  # iou = inter / (area1 + area2 - inter)

    def mask_iou(self, mask_and_label1: tuple[NDArray, NDArray], mask_and_label2: tuple[NDArray, NDArray]):
        """
        Return intersection-over-union (Jaccard index) of masks.
        Masks should be pixel arrays
        Arguments:
            two tuples of mask and label
        """
        mask1, label1 = mask_and_label1
        mask2, label2 = mask_and_label2
        thrs1 = self.thrs_config[label1]["mask_thr"]
        thrs2 = self.thrs_config[label2]["mask_thr"]
        mask1_area = np.count_nonzero(mask1 >= thrs1)
        mask2_area = np.count_nonzero(mask2 >= thrs2)
        intersection = np.count_nonzero(np.logical_and(mask1, mask2))
        iou = intersection / (mask1_area + mask2_area - intersection)
        return iou

    def mask_pairwise_iou(self, masks1: np.ndarray, masks2: np.ndarray, labels1: np.ndarray, labels2: np.ndarray):

        """Need to have been imnplemented eventually and tested"""

        f1 = np.array(zip(masks1, labels1))
        f2 = np.array(zip(masks2, labels2))
        return cdist(f1, f2, metric=self.mask_iou)  # TODO: implement it finally!

    def return_matrix(self):
        """Returns tuple of box and mask confusion matrix."""
        return self.box_matrix, self.mask_matrix

    def get_matrix_figure(self, type="box", pretty=True):
        """
        Returns figure of confusion matrix of either box or mask type

        Parameters
        ----------
        type: str, either box or mask, default `box`
        pretty: bool, default `True`
            plot pretty, featurize confusion matrix or just regular
        """
        if type == "box":
            if pretty:
                return pp_matrix(
                    self.box_matrix,
                    figsize=(14, 14),
                    rotation=False,
                    display_labels=self.display_labels,
                )
            else:
                return self.plot(figsize=(10, 10), type_matrix="boxes")
        else:
            if pretty:
                return pp_matrix(
                    self.mask_matrix,
                    figsize=(14, 14),
                    rotation=False,
                    display_labels=self.display_labels,
                )
            else:
                return self.plot(figsize=(10, 10), type_matrix="masks")

    def print_matrix(self):
        for i in range(self.num_classes + 1):
            print(" ".join(map(str, self.box_matrix[i])))

    def pretty_plot(
        self,
        type="box",
        figsize=(14, 14),
        rotation=False,
        cmap="viridis",
        ) -> Figure:
        """Plot feature rich confusion matrix.
        """
        if type=="box":
            return pp_matrix(
                        self.box_matrix,
                        figsize=figsize,
                        rotation=rotation,
                        display_labels=self.display_labels,
                        cmap=cmap,
                        show=True,
                    )
        else:
            return pp_matrix(
                        self.mask_matrix,
                        figsize=figsize,
                        rotation=rotation,
                        display_labels=self.display_labels,
                        cmap=cmap,
                        show=True,
                    )

    def plot(
        self,
        include_values=True,
        cmap="viridis",
        xticks_rotation="vertical",
        values_format=None,
        ax=None,
        colorbar=False,
        type_matrix="boxes",
        figsize=(9, 9),
    ) -> Figure:
        """Plot visualization of confusion matrix.

        Parameters
        ----------
        include_values : bool, default=True
            Includes values in confusion matrix.

        cmap : str or matplotlib Colormap, default='viridis'
            Colormap recognized by matplotlib.

        xticks_rotation : {'vertical', 'horizontal'} or float, \
                         default='horizontal'
            Rotation of xtick labels.

        values_format : str, default=None
            Format specification for values in confusion matrix. If `None`,
            the format specification is 'd' or '.2g' whichever is shorter.

        ax : matplotlib axes, default=None
            Axes object to plot on. If `None`, a new figure and axes is
            created.

        colorbar : bool, default=True
            Whether or not to add a colorbar to the plot.

        figsize : tuple, default (9,9)
            Size of figure.

        type_matrix : str, ether box or mask
            Type of matrix that need to plot.

        Returns
        -------
        display : :firuge:`plt.figure`
        """
        if ax is None:
            fig, ax = plt.subplots(figsize=figsize)
        else:
            fig = ax.figure

        cm = self.box_matrix if type_matrix == "boxes" else self.mask_matrix
        n_classes = cm.shape[0]
        self.im_ = ax.imshow(cm, interpolation="nearest", cmap=cmap)
        self.text_ = None
        cmap_min, cmap_max = self.im_.cmap(0), self.im_.cmap(1.0)

        if include_values:
            self.text_ = np.empty_like(cm, dtype=object)

            # print text with appropriate color depending on background
            thresh = (cm.max() + cm.min()) / 2.0

            for i, j in product(range(n_classes), range(n_classes)):
                color = cmap_max if cm[i, j] < thresh else cmap_min

                if values_format is None:
                    text_cm = format(cm[i, j], ".2g")
                    if cm.dtype.kind != "f":
                        text_d = format(cm[i, j], "d")
                        if len(text_d) < len(text_cm):
                            text_cm = text_d
                else:
                    text_cm = format(cm[i, j], values_format)

                self.text_[i, j] = ax.text(j, i, text_cm, ha="center", va="center", color=color)

        if self.display_labels is None:
            display_labels = np.arange(n_classes)
        else:
            display_labels = self.display_labels
        if colorbar:
            fig.colorbar(self.im_, ax=ax)
        ax.set(
            xticks=np.arange(n_classes),
            yticks=np.arange(n_classes),
            xticklabels=display_labels,
            yticklabels=display_labels,
            ylabel="True label",
            xlabel="Predicted label",
        )

        ax.set_ylim((n_classes - 0.5, -0.5))
        plt.setp(ax.get_xticklabels(), rotation=xticks_rotation)
        plt.tight_layout()
        plt.grid(False)

        self.figure_ = fig
        self.ax_ = ax
        return fig