valor-lite 0.33.8__py3-none-any.whl → 0.33.9__py3-none-any.whl

valor_lite/detection/metric.py

@@ -1,380 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-
-from valor_lite.schemas import Metric
-
-
-class MetricType(str, Enum):
-    Counts = "Counts"
-    Accuracy = "Accuracy"
-    Precision = "Precision"
-    Recall = "Recall"
-    F1 = "F1"
-    AP = "AP"
-    AR = "AR"
-    mAP = "mAP"
-    mAR = "mAR"
-    APAveragedOverIOUs = "APAveragedOverIOUs"
-    mAPAveragedOverIOUs = "mAPAveragedOverIOUs"
-    ARAveragedOverScores = "ARAveragedOverScores"
-    mARAveragedOverScores = "mARAveragedOverScores"
-    PrecisionRecallCurve = "PrecisionRecallCurve"
-    ConfusionMatrix = "ConfusionMatrix"
-
-    @classmethod
-    def base_metrics(cls):
-        return [
-            cls.Counts,
-            cls.Accuracy,
-            cls.Precision,
-            cls.Recall,
-            cls.F1,
-            cls.AP,
-            cls.AR,
-            cls.mAP,
-            cls.mAR,
-            cls.APAveragedOverIOUs,
-            cls.mAPAveragedOverIOUs,
-            cls.ARAveragedOverScores,
-            cls.mARAveragedOverScores,
-            cls.PrecisionRecallCurve,
-        ]
-
-
-@dataclass
-class Counts:
-    tp: int
-    fp: int
-    fn: int
-    label: str
-    iou_threshold: float
-    score_threshold: float
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value={
-                "tp": self.tp,
-                "fp": self.fp,
-                "fn": self.fn,
-            },
-            parameters={
-                "iou_threshold": self.iou_threshold,
-                "score_threshold": self.score_threshold,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class ClassMetric:
-    value: float
-    label: str
-    iou_threshold: float
-    score_threshold: float
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "iou_threshold": self.iou_threshold,
-                "score_threshold": self.score_threshold,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-class Precision(ClassMetric):
-    pass
-
-
-class Recall(ClassMetric):
-    pass
-
-
-class Accuracy(ClassMetric):
-    pass
-
-
-class F1(ClassMetric):
-    pass
-
-
-@dataclass
-class AP:
-    value: float
-    iou_threshold: float
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "iou_threshold": self.iou_threshold,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class mAP:
-    value: float
-    iou_threshold: float
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "iou_threshold": self.iou_threshold,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class APAveragedOverIOUs:
-    value: float
-    iou_thresholds: list[float]
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "iou_thresholds": self.iou_thresholds,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class mAPAveragedOverIOUs:
-    value: float
-    iou_thresholds: list[float]
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "iou_thresholds": self.iou_thresholds,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class AR:
-    value: float
-    score_threshold: float
-    iou_thresholds: list[float]
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "score_threshold": self.score_threshold,
-                "iou_thresholds": self.iou_thresholds,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class mAR:
-    value: float
-    score_threshold: float
-    iou_thresholds: list[float]
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "score_threshold": self.score_threshold,
-                "iou_thresholds": self.iou_thresholds,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class ARAveragedOverScores:
-    value: float
-    score_thresholds: list[float]
-    iou_thresholds: list[float]
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "score_thresholds": self.score_thresholds,
-                "iou_thresholds": self.iou_thresholds,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class mARAveragedOverScores:
-    value: float
-    score_thresholds: list[float]
-    iou_thresholds: list[float]
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "score_thresholds": self.score_thresholds,
-                "iou_thresholds": self.iou_thresholds,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class PrecisionRecallCurve:
-    """
-    Interpolated over recalls 0.0, 0.01, ..., 1.0.
-    """
-
-    precision: list[float]
-    iou_threshold: float
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.precision,
-            parameters={
-                "iou_threshold": self.iou_threshold,
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-@dataclass
-class ConfusionMatrix:
-    confusion_matrix: dict[
-        str,  # ground truth label value
-        dict[
-            str,  # prediction label value
-            dict[
-                str,  # either `count` or `examples`
-                int
-                | list[
-                    dict[
-                        str,  # either `datum`, `groundtruth`, `prediction` or score
-                        str  # datum uid
-                        | dict[
-                            str, float
-                        ]  # bounding box (xmin, xmax, ymin, ymax)
-                        | float,  # prediction score
-                    ]
-                ],
-            ],
-        ],
-    ]
-    hallucinations: dict[
-        str,  # prediction label value
-        dict[
-            str,  # either `count` or `examples`
-            int
-            | list[
-                dict[
-                    str,  # either `datum`, `prediction` or score
-                    str  # datum uid
-                    | float  # prediction score
-                    | dict[
-                        str, float
-                    ],  # bounding box (xmin, xmax, ymin, ymax)
-                ]
-            ],
-        ],
-    ]
-    missing_predictions: dict[
-        str,  # ground truth label value
-        dict[
-            str,  # either `count` or `examples`
-            int
-            | list[
-                dict[
-                    str,  # either `datum` or `groundtruth`
-                    str  # datum uid
-                    | dict[
-                        str, float
-                    ],  # bounding box (xmin, xmax, ymin, ymax)
-                ]
-            ],
-        ],
-    ]
-    score_threshold: float
-    iou_threshold: float
-    number_of_examples: int
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value={
-                "confusion_matrix": self.confusion_matrix,
-                "hallucinations": self.hallucinations,
-                "missing_predictions": self.missing_predictions,
-            },
-            parameters={
-                "score_threshold": self.score_threshold,
-                "iou_threshold": self.iou_threshold,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()

valor_lite/segmentation/annotation.py

@@ -1,49 +0,0 @@
-from dataclasses import dataclass, field
-
-import numpy as np
-from numpy.typing import NDArray
-
-
-@dataclass
-class Bitmask:
-    mask: NDArray[np.bool_]
-    label: str
-
-    def __post_init__(self):
-        if self.mask.dtype != np.bool_:
-            raise ValueError(
-                f"Bitmask recieved mask with dtype `{self.mask.dtype}`."
-            )
-
-
-@dataclass
-class Segmentation:
-    uid: str
-    groundtruths: list[Bitmask]
-    predictions: list[Bitmask]
-    shape: tuple[int, ...] = field(default_factory=lambda: (0, 0))
-    size: int = field(default=0)
-
-    def __post_init__(self):
-
-        groundtruth_shape = {
-            groundtruth.mask.shape for groundtruth in self.groundtruths
-        }
-        prediction_shape = {
-            prediction.mask.shape for prediction in self.predictions
-        }
-        if len(groundtruth_shape) == 0:
-            raise ValueError("The segmenation is missing ground truths.")
-        elif len(prediction_shape) == 0:
-            raise ValueError("The segmenation is missing predictions.")
-        elif (
-            len(groundtruth_shape) != 1
-            or len(prediction_shape) != 1
-            or groundtruth_shape != prediction_shape
-        ):
-            raise ValueError(
-                "A shape mismatch exists within the segmentation."
-            )
-
-        self.shape = groundtruth_shape.pop()
-        self.size = int(np.prod(np.array(self.shape)))

valor_lite/segmentation/metric.py

@@ -1,119 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-
-from valor_lite.schemas import Metric
-
-
-class MetricType(Enum):
-    Precision = "Precision"
-    Recall = "Recall"
-    Accuracy = "Accuracy"
-    F1 = "F1"
-    IoU = "IoU"
-    mIoU = "mIoU"
-    ConfusionMatrix = "ConfusionMatrix"
-
-    @classmethod
-    def base(cls):
-        return [
-            cls.Precision,
-            cls.Recall,
-            cls.Accuracy,
-            cls.F1,
-            cls.IoU,
-            cls.mIoU,
-            cls.ConfusionMatrix,
-        ]
-
-
-@dataclass
-class _LabelValue:
-    value: float
-    label: str
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={
-                "label": self.label,
-            },
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-class Precision(_LabelValue):
-    pass
-
-
-class Recall(_LabelValue):
-    pass
-
-
-class F1(_LabelValue):
-    pass
-
-
-class IoU(_LabelValue):
-    pass
-
-
-@dataclass
-class _Value:
-    value: float
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value=self.value,
-            parameters={},
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()
-
-
-class Accuracy(_Value):
-    pass
-
-
-class mIoU(_Value):
-    pass
-
-
-@dataclass
-class ConfusionMatrix:
-    confusion_matrix: dict[
-        str,  # ground truth label value
-        dict[
-            str,  # prediction label value
-            dict[str, float],  # iou
-        ],
-    ]
-    hallucinations: dict[
-        str,  # prediction label value
-        dict[str, float],  # percentage of pixels
-    ]
-    missing_predictions: dict[
-        str,  # ground truth label value
-        dict[str, float],  # percentage of pixels
-    ]
-
-    @property
-    def metric(self) -> Metric:
-        return Metric(
-            type=type(self).__name__,
-            value={
-                "confusion_matrix": self.confusion_matrix,
-                "hallucinations": self.hallucinations,
-                "missing_predictions": self.missing_predictions,
-            },
-            parameters={},
-        )
-
-    def to_dict(self) -> dict:
-        return self.metric.to_dict()

valor_lite-0.33.8.dist-info/METADATA

@@ -1,41 +0,0 @@
-Metadata-Version: 2.1
-Name: valor-lite
-Version: 0.33.8
-Summary: Compute valor metrics directly in your client.
-License: MIT License
-        
-        Copyright (c) 2023 Striveworks
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy
-        of this software and associated documentation files (the "Software"), to deal
-        in the Software without restriction, including without limitation the rights
-        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-        copies of the Software, and to permit persons to whom the Software is
-        furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all
-        copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-        SOFTWARE.
-        
-Project-URL: homepage, https://www.striveworks.com
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: Pillow >=9.1.0
-Requires-Dist: tqdm
-Requires-Dist: requests
-Requires-Dist: numpy
-Requires-Dist: shapely
-Requires-Dist: importlib-metadata ; python_version < "3.8"
-Provides-Extra: test
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: coverage ; extra == 'test'
-
-# valor-lite: Compute classification, object detection, and segmentation metrics locally.

valor_lite-0.33.8.dist-info/RECORD

@@ -1,22 +0,0 @@
-valor_lite/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-valor_lite/schemas.py,sha256=r4cC10w1xYsA785KmGE4ePeOX3wzEs846vT7QAiVg_I,293
-valor_lite/classification/__init__.py,sha256=2wmmziIzUATm7MbmAcPNLXrEX5l4oeD7XBwPd9bWM3Q,506
-valor_lite/classification/annotation.py,sha256=efgwbkOYoujkg9r0CuzMIRfl93DuZV2ldQeW0CBVfeU,478
-valor_lite/classification/computation.py,sha256=qd9K7CcSGmMm_7shfX47_ZIuB-uE2LLiLMZSS_3NJTk,12093
-valor_lite/classification/manager.py,sha256=6YlkqCwuTcAoa40LU0EfXQyZFTwPyRnt5W19qs-T3Xk,24718
-valor_lite/classification/metric.py,sha256=tAxeuTvO5M9gsQWk47hT_Yea6lbfExe16FgkWYmjKGw,3763
-valor_lite/detection/__init__.py,sha256=PiKfemo8FkZRzBhPSjhil8ahGURLy0Vk_iV25CB4UBU,1139
-valor_lite/detection/annotation.py,sha256=kuW8PF4bitPA6cd5Unr5zqgw8nLnvM4BY0jZW14WFAI,4396
-valor_lite/detection/computation.py,sha256=7rOfVlYDadXcJ1_S0FJRF3IPigcsR7guk_0rXeIdAOE,26919
-valor_lite/detection/manager.py,sha256=QzSkiGUYJ4Z6o1QZKPe36Yc74u052h8g36-fUowRlv0,42620
-valor_lite/detection/metric.py,sha256=Wz4xHg0A7E7BFdUPMnrKnz63P6sD7pwHYM1UQ9_dsgY,8872
-valor_lite/segmentation/__init__.py,sha256=IdarTHKUuUMDvMBmInQu12Mm_NMCbql6Hf0nL5b56Ak,424
-valor_lite/segmentation/annotation.py,sha256=8m5ZsRAcDwQVEvn576Ec1DiNwvtxdKQJXpYoToRugfk,1412
-valor_lite/segmentation/computation.py,sha256=iJkEmTNmw9HwQCxSnpJkQsAdVcFriGhhu_WMks6D7tU,5122
-valor_lite/segmentation/manager.py,sha256=zn-l5NyrkaRck8dq5VOKCJFOtylSXsWuiQ_eBV8m8JM,16921
-valor_lite/segmentation/metric.py,sha256=hNn3lB-XJK5YW3itOWvvRMl6hZyWHMlC6smyeVhxeJE,2275
-valor_lite-0.33.8.dist-info/LICENSE,sha256=M0L53VuwfEEqezhHb7NPeYcO_glw7-k4DMLZQ3eRN64,1068
-valor_lite-0.33.8.dist-info/METADATA,sha256=MRi4I1Bu8ojuc9aUSWzkaaH9l5JMRUmenvHdo6bh50o,1865
-valor_lite-0.33.8.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-valor_lite-0.33.8.dist-info/top_level.txt,sha256=9ujykxSwpl2Hu0_R95UQTR_l07k9UUTSdrpiqmq6zc4,11
-valor_lite-0.33.8.dist-info/RECORD,,