Skip to content

landingai.postprocess

class_counts(predictions)

Compute the distribution of the occurrences of each class.

Returns

A map with the predicted class/label index as the key, and a tuple of (the number of occurrence, class/label name) as the value. 

Example:
    {
        1: (10, "cat"),
        2: (31, "dog"),
    }

Source code in landingai/postprocess.py 
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
def class_counts(
    predictions: Sequence[ClassificationPrediction],
) -> Dict[int, Tuple[int, str]]:
    """Compute the distribution of the occurrences of each class.

    Returns
    -------
    A map with the predicted class/label index as the key, and a tuple of
        (the number of occurrence, class/label name) as the value.
        ```
        Example:
            {
                1: (10, "cat"),
                2: (31, "dog"),
            }
        ```
    """
    counts: Dict[int, List[Union[int, str]]] = defaultdict(lambda: [0, ""])
    for pred in predictions:
        counts[pred.label_index][0] = cast(int, counts[pred.label_index][0]) + 1
        counts[pred.label_index][1] = pred.label_name
    return {k: (cast(int, v[0]), cast(str, v[1])) for k, v in counts.items()}

class_map(predictions)

Return a map from the predicted class/label index to the class/label name.

Source code in landingai/postprocess.py 
110
111
112
def class_map(predictions: Sequence[ClassificationPrediction]) -> Dict[int, str]:
    """Return a map from the predicted class/label index to the class/label name."""
    return {pred.label_index: pred.label_name for pred in predictions}

class_pixel_coverage(predictions, coverage_type='relative')

Compute the pixel coverage of each class.

Supported prediction types are: - SegmentationPrediction - ObjectDetectionPrediction

It supports two ways to compute the coverage: - "absolute" - "relative" See the documentation of the coverage_type for more details.

Parameters

predictions: a list of predictions. It could come from one or multiple images. coverage_type: "absolute" or "relative". - Absolute: The number of pixels of each predicted class. - Relative: The percentage of pixels that are predicted as the class over the sum total number of pixels of every mask. The only project type that supports "relative" is "SegmentationPrediction".

Returns

A map with the predicted class/label index as the key, and a tuple of (the coverage, class/label name) as the value. 

Example (coverage_type="absolute"):
    {
        0: (23512, "blue"),
        1: (1230, "green"),
        2: (0, "pink"),
    }

Source code in landingai/postprocess.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
def class_pixel_coverage(
    predictions: Sequence[ClassificationPrediction],
    coverage_type: str = "relative",
) -> Dict[int, Tuple[float, str]]:
    """Compute the pixel coverage of each class.

    Supported prediction types are:
    - SegmentationPrediction
    - ObjectDetectionPrediction

    It supports two ways to compute the coverage:
    - "absolute"
    - "relative"
    See the documentation of the coverage_type for more details.

    Parameters
    ----------
    predictions: a list of predictions. It could come from one or multiple images.
    coverage_type: "absolute" or "relative".
            - Absolute: The number of pixels of each predicted class.
            - Relative: The percentage of pixels that are predicted as the class
               over the sum total number of pixels of every mask. The only project type that supports "relative" is "SegmentationPrediction".


    Returns
    -------
    A map with the predicted class/label index as the key, and a tuple of
        (the coverage, class/label name) as the value.
        ```
        Example (coverage_type="absolute"):
            {
                0: (23512, "blue"),
                1: (1230, "green"),
                2: (0, "pink"),
            }
        ```
    """
    assert isinstance(
        predictions[0], SegmentationPrediction
    ), "Only support SegmentationPrediction for now."
    predictions = cast(List[SegmentationPrediction], predictions)
    return segmentation_class_pixel_coverage(predictions, coverage_type)

crop(predictions, image)

Crop the image based on the bounding boxes in the predictions.

NOTE: Currently, only ObjectDetectionPrediction is supported. If other types of predictions are passed in, a ValueError will be raised.

Parameters

predictions: a list of ObjectDetectionPrediction, each of which will be used to crop the image. image: the input image to be cropped from.

Returns

A list of cropped images.

Source code in landingai/postprocess.py 
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
def crop(
    predictions: Sequence[Prediction], image: Union[np.ndarray, Image]
) -> Sequence[Image]:
    """Crop the image based on the bounding boxes in the predictions.

    NOTE: Currently, only ObjectDetectionPrediction is supported. If other types of predictions are passed in, a ValueError will be raised.

    Parameters
    ----------
    predictions: a list of ObjectDetectionPrediction, each of which will be used to crop the image.
    image: the input image to be cropped from.

    Returns
    -------
    A list of cropped images.
    """
    if len(predictions) == 0:
        return []
    if isinstance(image, np.ndarray):
        image = PIL.Image.fromarray(image)
    output = []
    for pred in predictions:
        if not isinstance(pred, ObjectDetectionPrediction):
            raise ValueError(
                f"Only ObjectDetectionPrediction is supported but {type(pred)} is found."
            )
        output.append(image.crop(pred.bboxes))
    return output

rescale_bboxes(predictions, scale_factor)

Rescale the bounding boxes of each ObjectDetectionPrediction in a list based on the scale factor. NOTE: this operation is NOT in-place. The input predictions will remain the same.

Parameters

predictions: a list of ObjectDetectionPrediction to be rescaled. scale_factor: the scale factor that will be applied to the predictions. The scale factors are (height, width) if it's a tuple.

Returns

A list of ObjectDetectionPrediction where the bboxes has been rescaled.

Source code in landingai/postprocess.py 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
def rescale_bboxes(
    predictions: Sequence[ObjectDetectionPrediction],
    scale_factor: Union[Tuple[float, float], float],
) -> Sequence[ObjectDetectionPrediction]:
    """Rescale the bounding boxes of each ObjectDetectionPrediction in a list based on the scale factor.
    NOTE: this operation is NOT in-place. The input predictions will remain the same.

    Parameters
    ----------
    predictions: a list of ObjectDetectionPrediction to be rescaled.
    scale_factor: the scale factor that will be applied to the predictions. The scale factors are (height, width) if it's a tuple.

    Returns
    -------
    A list of ObjectDetectionPrediction where the bboxes has been rescaled.
    """
    if isinstance(scale_factor, float):
        scale_factor = (scale_factor, scale_factor)
    assert scale_factor[0] > 0 and scale_factor[1] > 0, "Scale factor must be > 0"
    height_scale, width_scale = scale_factor
    return [
        ObjectDetectionPrediction(
            id=pred.id,
            score=pred.score,
            label_index=pred.label_index,
            label_name=pred.label_name,
            bboxes=(
                math.floor(pred.bboxes[0] * width_scale),  # xmin
                math.floor(pred.bboxes[1] * height_scale),  # ymin
                math.ceil(pred.bboxes[2] * width_scale),  # xmax
                math.ceil(pred.bboxes[3] * height_scale),  # ymax
            ),
        )
        for pred in predictions
    ]

rescale_bboxes_by_image_size(predictions, from_image, to_image)

Rescale the bounding boxes of each ObjectDetectionPrediction in a list based on the size of the reference images. NOTE: this operation is NOT in-place. The input predictions will remain the same.

Parameters

predictions: a list of ObjectDetectionPrediction to be rescaled. from_image: the image that serves the denominator of the scale factor. The input bboxes is at the same scale of this image. to_image: the image that serves the numerator of the scale factor. The ouput bboxes will be at the same scale of this image.

Returns

A list of ObjectDetectionPrediction where the bboxes has been rescaled.

Source code in landingai/postprocess.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
def rescale_bboxes_by_image_size(
    predictions: Sequence[ObjectDetectionPrediction],
    from_image: Image,
    to_image: Image,
) -> Sequence[ObjectDetectionPrediction]:
    """Rescale the bounding boxes of each ObjectDetectionPrediction in a list based on the size of the reference images.
    NOTE: this operation is NOT in-place. The input predictions will remain the same.

    Parameters
    ----------
    predictions: a list of ObjectDetectionPrediction to be rescaled.
    from_image: the image that serves the denominator of the scale factor. The input bboxes is at the same scale of this image.
    to_image: the image that serves the numerator of the scale factor. The ouput bboxes will be at the same scale of this image.

    Returns
    -------
    A list of ObjectDetectionPrediction where the bboxes has been rescaled.
    """
    scale_factor = (
        to_image.size[1] / from_image.size[1],
        to_image.size[0] / from_image.size[0],
    )
    return rescale_bboxes(predictions, scale_factor)

segmentation_class_pixel_coverage(predictions, coverage_type='relative')

Compute the pixel coverage of each class. The coverage is defined as the percentage of pixels that are predicted as the class over the sum total number of pixels of every mask. If the predictions are from multiple images, the coverage is the average coverage across all images.

Parameters

predictions: A list of segmentation predictions. It could come from one or multiple images.

Returns

A map with the predicted class/label index as the key, and a tuple of (the coverage percentage, class/label name) as the value. Note: The sum of the coverage percentage over all classes is not guaranteed to be 1. 

Example (coverage_type="relative"):
    {
        0: (0.15, "blue"),
        1: (0.31, "green"),
        2: (0.07, "pink"),
    }

Source code in landingai/postprocess.py 
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
def segmentation_class_pixel_coverage(
    predictions: Sequence[SegmentationPrediction],
    coverage_type: str = "relative",
) -> Dict[int, Tuple[float, str]]:
    """Compute the pixel coverage of each class.
    The coverage is defined as the percentage of pixels that are predicted as the class
    over the sum total number of pixels of every mask.
    If the predictions are from multiple images, the coverage is the average coverage across all images.

    Parameters
    ----------
    predictions: A list of segmentation predictions. It could come from one or multiple images.

    Returns
    -------
    A map with the predicted class/label index as the key, and a tuple of
        (the coverage percentage, class/label name) as the value.
        Note: The sum of the coverage percentage over all classes is not guaranteed
        to be 1.
        ```
        Example (coverage_type="relative"):
            {
                0: (0.15, "blue"),
                1: (0.31, "green"),
                2: (0.07, "pink"),
            }
        ```
    """
    pixel_coverages = []
    label_map = {}
    for pred in predictions:
        coverage = cast(float, pred.num_predicted_pixels)
        if coverage_type == "relative":
            coverage /= math.prod(pred.mask_shape)
        pixel_coverages.append((pred.label_index, coverage))
        label_map[pred.label_index] = pred.label_name

    sorted(pixel_coverages, key=lambda x: x[0])
    coverage_by_label: Dict[int, Tuple[float, str]] = {}
    for label_index, group in groupby(pixel_coverages, key=lambda x: x[0]):
        cov_vals = [item[1] for item in list(group)]
        avg_coverage = sum(cov_vals) / len(cov_vals) if len(cov_vals) > 0 else 0
        coverage_by_label[label_index] = (avg_coverage, label_map[label_index])
    return coverage_by_label