sinapsis-anomalib 0.1.0__py3-none-any.whl

sinapsis_anomalib/helpers/config_factory.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+from typing import Any
+
+from anomalib.loggers import (
+    AnomalibCometLogger,
+    AnomalibMLFlowLogger,
+    AnomalibTensorBoardLogger,
+    AnomalibWandbLogger,
+)
+from lightning.pytorch.callbacks import (
+    Callback,
+    DeviceStatsMonitor,
+    EarlyStopping,
+    LearningRateMonitor,
+    ModelCheckpoint,
+    RichProgressBar,
+)
+from lightning.pytorch.loggers import (
+    CometLogger,
+    MLFlowLogger,
+    TensorBoardLogger,
+    WandbLogger,
+)
+
+
+class CallbackFactory:
+    """A factory class for creating and managing PyTorch Lightning callbacks.
+
+    This class provides a centralized way to create and register callbacks for use in PyTorch Lightning
+    training workflows. It supports built-in callbacks like `RichProgressBar`, `EarlyStopping`, and
+    `ModelCheckpoint`, and allows users to register custom callbacks.
+    """
+
+    def __init__(self) -> None:
+        self.callbacks = {
+            "rich_progress": RichProgressBar,
+            "early_stopping": EarlyStopping,
+            "model_checkpoint": ModelCheckpoint,
+            "lr_monitor": LearningRateMonitor,
+            "device_stats": DeviceStatsMonitor,
+        }
+
+    def create(self, callback_name: str, config: dict[str, Any] | None = None) -> Callback:
+        """Creates an instance of the specified callback.
+
+        Args:
+            callback_name (str): The name of the callback to create. Must be a key in the `callbacks` dictionary.
+            config (dict[str, Any] | None, optional): A dictionary of configuration parameters for the callback.
+                If provided, these parameters will be passed to the callback's constructor. Defaults to None.
+
+        Raises:
+            ValueError: If the specified `callback_name` is not found in the `callbacks` dictionary.
+
+        Returns:
+            Callback: An instance of the requested callback.
+        """
+        callback_class = self.callbacks.get(callback_name)
+        if not callback_class:
+            raise ValueError(f"Callback {callback_name} not supported")
+
+        if config:
+            return callback_class(**config)
+        return callback_class()
+
+    def register_callback(self, name: str, callback_class: type[Callback]) -> None:
+        """Registers a new callback class with the factory.
+
+        Args:
+            name (str): The name to associate with the callback.
+            callback_class (type[Callback]): The callback class to register.
+        """
+        self.callbacks[name] = callback_class
+
+
+class LoggerFactory:
+    """A factory class for creating and managing PyTorch Lightning loggers.
+
+    This class provides a centralized way to create and register loggers for use in PyTorch Lightning
+    training workflows. It supports built-in loggers like `TensorBoardLogger`, `WandbLogger`, and
+    `MLFlowLogger`, and allows users to register custom loggers.
+    """
+
+    def __init__(self) -> None:
+        self.loggers = {
+            "tensorboard": AnomalibTensorBoardLogger,
+            "wandb": AnomalibWandbLogger,
+            "mlflow": AnomalibMLFlowLogger,
+            "comet": AnomalibCometLogger,
+        }
+
+    def create(
+        self, logger_name: str, config: dict[str, Any] | None = None
+    ) -> TensorBoardLogger | WandbLogger | MLFlowLogger | CometLogger:
+        """Creates an instance of the specified logger.
+
+        Args:
+            logger_name (str): The name of the logger to create. Must be a key in the `loggers` dictionary.
+            config (dict[str, Any] | None, optional): A dictionary of configuration parameters for the logger.
+                If provided, these parameters will be passed to the logger's constructor. Defaults to None.
+
+        Raises:
+            ValueError: If the specified `logger_name` is not found in the `loggers` dictionary.
+
+        Returns:
+            TensorBoardLogger | WandbLogger | MLFlowLogger | CometLogger: An instance of the requested logger.
+        """
+        logger_class = self.loggers.get(logger_name)
+        if not logger_class:
+            raise ValueError(f"Logger {logger_name} not supported")
+
+        if config:
+            return logger_class(**config)
+        return logger_class()
+
+    def register_logger(self, name: str, logger_class: type) -> None:
+        """Registers a new logger class with the factory.
+
+        Args:
+            name (str): The name to associate with the logger.
+            logger_class (type): The logger class to register.
+        """
+        self.loggers[name] = logger_class

sinapsis_anomalib/templates/__init__.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+import importlib
+from typing import Callable, cast
+
+from sinapsis.templates import _import_template_package
+
+_root_lib_path = "sinapsis_anomalib.templates"
+_ADDITIONAL_TEMPLATE_MODULES = [
+    f"{_root_lib_path}.anomalib_train",
+    f"{_root_lib_path}.anomalib_export",
+]
+
+
+_template_lookup: dict = {
+    "AnomalibTorchInference": f"{_root_lib_path}.anomalib_torch_inference",
+    "AnomalibOpenVINOInference": f"{_root_lib_path}.anomalib_openvino_inference",
+}
+
+
+for t_module in _ADDITIONAL_TEMPLATE_MODULES:
+    _template_lookup |= _import_template_package(t_module)
+
+
+def __getattr__(name: str) -> Callable:
+    if name in _template_lookup:
+        module = importlib.import_module(_template_lookup[name])
+        return cast(Callable, getattr(module, name))
+    raise AttributeError(f"template `{name}` not found in {_root_lib_path}")
+
+
+__all__ = list(_template_lookup.keys())

sinapsis_anomalib/templates/anomalib_base.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+from abc import abstractmethod
+from collections.abc import Iterable, Sequence
+from pathlib import Path
+from typing import Any, Protocol, TypeAlias
+
+from anomalib import models as anomalib_models
+from anomalib.data import Folder
+from anomalib.engine import Engine
+from anomalib.utils.types import NORMALIZATION, THRESHOLD
+from lightning.pytorch.callbacks import Callback
+from lightning.pytorch.loggers import Logger
+from pydantic import BaseModel, ConfigDict
+from pydantic.dataclasses import dataclass
+from sinapsis_core.data_containers.data_packet import DataContainer
+from sinapsis_core.template_base import TemplateAttributes, TemplateAttributeType
+from sinapsis_core.template_base.dynamic_template import BaseDynamicWrapperTemplate, WrapperEntryConfig
+
+from sinapsis_anomalib.helpers.config_factory import CallbackFactory, LoggerFactory
+
+EXCLUDED_MODELS = [
+    "EfficientAd",
+    "VlmAd",
+    "Cfa",
+    "Dfkde",
+    "Fastflow",
+    "Supersimplenet",
+    "AiVad",
+]
+
+
+@dataclass(frozen=True)
+class AnomalibKeys:
+    """Constants for accessing Anomalib Engine configuration sections.
+
+    Attributes:
+        CALLBACKS (str): Key for callback configurations in Engine setup
+        LOGGER (str): Key for logger configurations in Engine setup
+    """
+
+    CALLBACKS: str = "callbacks"
+    LOGGER: str = "logger"
+
+
+METRICS_TYPE: TypeAlias = list[str] | str | dict[str, dict[str, Any]]
+PATH_TYPE: TypeAlias = str | Path | None
+PATH_SEQUENCE_TYPE: TypeAlias = str | Path | Sequence[str | Path] | None
+LOGGER_TYPE: TypeAlias = Logger | Iterable[Logger] | bool | None
+
+
+class EngineConfig(BaseModel):
+    """Pydantic model for Anomalib Engine configuration.
+
+    Attributes:
+        callbacks (list[Callback] | None): List of PyTorch Lightning callbacks
+        normalization (NORMALIZATION | None): Input normalization configuration
+        threshold (THRESHOLD | None): Anomaly threshold configuration
+        image_metrics (METRICS_TYPE | None): Image-level evaluation metrics
+        pixel_metrics (METRICS_TYPE | None): Pixel-level evaluation metrics
+        logger (LOGGER_TYPE): Logger configuration
+        default_root_dir (PATH_TYPE): Root directory for outputs
+        callback_configs (dict[str, dict[str, Any]] | None): Callback configurations
+        logger_configs (dict[str, dict[str, Any]] | None): Logger configurations
+    """
+
+    callbacks: list[Callback] | None = None
+    normalization: NORMALIZATION | None = None
+    threshold: THRESHOLD | None = None
+    image_metrics: METRICS_TYPE | None = None
+    pixel_metrics: METRICS_TYPE | None = None
+    logger: LOGGER_TYPE = None
+    default_root_dir: PATH_TYPE = None
+    callback_configs: dict[str, dict[str, Any]] | None = None
+    logger_configs: dict[str, dict[str, Any]] | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class HasSUFFIX(Protocol):
+    """Protocol for classes that have a SUFFIX attribute.
+
+    Attributes:
+        SUFFIX (str): Class attribute suffix string
+    """
+
+    SUFFIX: str
+
+
+class DynamicWrapperEntry:
+    """Descriptor that dynamically generates WrapperEntryConfig based on owner's SUFFIX."""
+
+    def __get__(self, _instance: object, owner: type[HasSUFFIX]) -> WrapperEntryConfig:
+        """Dynamically create WrapperEntryConfig based on the SUFFIX value.
+
+        Args:
+            _instance (object): Unused instance reference
+            owner (type[HasSUFFIX]): Owning class with SUFFIX attribute
+
+        Returns:
+            WrapperEntryConfig: Configured wrapper entry
+        """
+        return WrapperEntryConfig(
+            wrapped_object=anomalib_models,
+            template_name_suffix=owner.SUFFIX,
+            exclude_module_atts=EXCLUDED_MODELS,
+        )
+
+
+class AnomalibBaseAttributes(TemplateAttributes):
+    """Base attributes for Anomalib model templates.
+
+    Attributes:
+        folder_attributes (dict[str, Any]): Configuration for Folder datamodule. Required for training, optional
+            for export.
+        callbacks (list[Callback] | None): Lightning callbacks
+        normalization (NORMALIZATION | None): Input normalization
+        threshold (THRESHOLD | None): Prediction threshold
+        image_metrics (METRICS_TYPE | None): Image metrics
+        pixel_metrics (METRICS_TYPE | None): Pixel metrics
+        logger (LOGGER_TYPE): Lightning logger
+        default_root_dir (PATH_TYPE): Output directory
+        callback_configs (dict[str, dict[str, Any]] | None): Callback configs
+        logger_configs (dict[str, dict[str, Any]] | None): Logger configs
+    """
+
+    folder_attributes: dict[str, Any] | None = None
+    callbacks: list[Callback] | None = None
+    normalization: NORMALIZATION | None = None
+    threshold: THRESHOLD | None = None
+    image_metrics: METRICS_TYPE | None = None
+    pixel_metrics: METRICS_TYPE | None = None
+    logger: LOGGER_TYPE = None
+    default_root_dir: PATH_TYPE = None
+    callback_configs: dict[str, dict[str, Any]] | None = None
+    logger_configs: dict[str, dict[str, Any]] | None = None
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class AnomalibBase(BaseDynamicWrapperTemplate):
+    """Base class for Anomalib model Train and Export templates.
+
+    Notes:
+        - Subclasses must override SUFFIX as needed for their specific purpose
+        - When using 'Train' suffix, all essential Folder attributes must be provided
+        - INT8_PTQ/INT8_ACQ compression requires complete Folder configuration
+        - Callback and logger configurations are optional but must follow Anomalib specs
+    """
+
+    SUFFIX: str = "Wrapper"
+    AttributesBaseModel = AnomalibBaseAttributes
+    CATEGORY = "Anomalib"
+    WrapperEntry = DynamicWrapperEntry()
+
+    def __init__(self, attributes: TemplateAttributeType) -> None:
+        super().__init__(attributes=attributes)
+        self.model = self.wrapped_callable
+        self.callback_factory = CallbackFactory()
+        self.logger_factory = LoggerFactory()
+        self.engine = self.setup_engine()
+
+    def _create_callbacks(self) -> list[Callback]:
+        """Create callbacks from configuration.
+
+        Returns:
+            list[Callback]: Instantiated callback objects
+        """
+        return [self.callback_factory.create(name, config) for name, config in self.attributes.callback_configs.items()]
+
+    def _create_loggers(self) -> list[Logger]:
+        """Create loggers from configuration.
+
+        Returns:
+            list[Logger]: Instantiated logger objects
+        """
+        return [self.logger_factory.create(name, config) for name, config in self.attributes.logger_configs.items()]
+
+    def setup_engine(self) -> Engine:
+        """Configure and initialize the Anomalib Engine.
+
+        Returns:
+            Engine: Configured engine instance
+        """
+        engine_kwargs = EngineConfig(**self.attributes.model_dump()).model_dump(
+            exclude={"callback_configs", "logger_configs"}, exclude_none=True
+        )
+        if self.attributes.callback_configs:
+            engine_kwargs[AnomalibKeys.CALLBACKS] = self._create_callbacks()
+
+        if self.attributes.logger_configs:
+            engine_kwargs[AnomalibKeys.LOGGER] = self._create_loggers()
+
+        return Engine(**engine_kwargs)
+
+    def setup_data_loader(self) -> Folder:
+        """Initialize the data loader from folder attributes if provided.
+
+        Returns:
+            Folder: Configured data module instance
+        """
+        return Folder(**self.attributes.folder_attributes)
+
+    @abstractmethod
+    def execute(self, container: DataContainer) -> DataContainer:
+        """Template method to be implemented by subclasses.
+
+        Args:
+            container (DataContainer): Input data container
+
+        Returns:
+            DataContainer: Processed data container
+        """

sinapsis_anomalib/templates/anomalib_base_inference.py

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+from abc import abstractmethod
+from copy import deepcopy
+
+import cv2 as cv
+import numpy as np
+import torchvision.transforms.v2 as T
+from anomalib.data.utils.label import LabelName
+from anomalib.deploy import OpenVINOInferencer, TorchInferencer
+from pydantic import Field
+from pydantic.dataclasses import dataclass
+from sinapsis_core.data_containers.annotations import (
+    BoundingBox,
+    ImageAnnotations,
+    Segmentation,
+)
+from sinapsis_core.data_containers.data_packet import DataContainer, ImagePacket
+from sinapsis_core.template_base import (
+    Template,
+    TemplateAttributes,
+    TemplateAttributeType,
+)
+
+
+@dataclass(frozen=True)
+class AnomalibInferenceKeys:
+    """Constants representing keys used in Anomalib inference operations.
+
+    Attributes:
+        TRANSFORMS (str): Key for image transformation configuration
+        TASK (str): Key for task type specification
+        ANOMALOUS (str): Key representing anomalous/abnormal classification
+        NORMAL (str): Key representing normal classification
+    """
+
+    TRANSFORMS: str = "transforms"
+    TASK: str = "task"
+    ANOMALOUS: str = "anomalous"
+    NORMAL: str = "normal"
+
+
+class AnomalibInferenceAttributes(TemplateAttributes):
+    """Configuration attributes for Anomalib inference templates.
+
+    Attributes:
+        model_path (str): Path to the exported model file
+        transforms (list[str] | None): Optional list of additional image transformation names to apply
+        anomaly_area_threshold (float): The minimum area to be considered a valid anomaly detection. Defaults to 100.
+    """
+
+    model_path: str
+    transforms: dict = Field(default_factory=dict)
+    anomaly_area_threshold: float = 100
+
+
+class AnomalibBaseInference(Template):
+    """Base class for Anomalib model inference implementations.
+
+    Provides common functionality for processing images through Anomalib models,
+    handling classification, segmentation, and detection tasks.
+    """
+
+    AttributesBaseModel = AnomalibInferenceAttributes
+    CATEGORY = "Anomalib"
+
+    def __init__(self, attributes: TemplateAttributeType) -> None:
+        super().__init__(attributes)
+        self.inferencer = self.get_inferencer()
+        self.transform = self._build_transforms()
+
+    @abstractmethod
+    def get_inferencer(self) -> TorchInferencer | OpenVINOInferencer:
+        """Initialize and return the appropriate inferencer instance. Subclasses must implement this method.
+
+        Returns:
+            TorchInferencer | OpenVINOInferencer: Either a TorchInferencer or OpenVINOInferencer instance
+        """
+
+    def _convert_transform_names(self) -> list[T.Transform]:
+        """Convert transform names to actual transform callables.
+
+        Returns:
+            list[T.Transform]: List of corresponding transform callable objects
+        """
+        transforms = []
+        for name, params in self.attributes.transforms.items():
+            if hasattr(T, name):
+                transform_class = getattr(T, name)
+                if params:
+                    transforms.append(transform_class(**params))
+                else:
+                    transforms.append(transform_class())
+
+        return transforms
+
+    @abstractmethod
+    def get_transformation_list(self) -> list[T.Transform]:
+        """Construct the list of transformation according to the specified inferencer.
+
+        Returns:
+            list[T.Transform]: List of transformations.
+        """
+
+    def _build_transforms(self) -> T.Compose:
+        """Build the complete transform pipeline for image preprocessing.
+
+        Returns:
+            T.Compose: A composed transform pipeline
+        """
+        transforms = self.get_transformation_list()
+
+        return T.Compose(transforms)
+
+    @staticmethod
+    @abstractmethod
+    def postprocess_segmentation_mask(binary_mask: np.ndarray, image: np.ndarray) -> np.ndarray:
+        """Apply postprocessing operations to the generated mask according to the used inferenceer.
+
+        Args:
+            binary_mask (np.ndarray): Mask produced by inferencer.
+            image (np.ndarray): Original image.
+
+        Returns:
+            np.ndarray: Post-processed mask.
+        """
+
+    def get_boxes_from_mask(self, np_mask: np.ndarray) -> list[list[float]]:
+        """Produce a list of bounding boxes from the predicted segmentation mask.
+
+        Args:
+            np_mask (np.ndarray): Predicted binary mask.
+
+        Returns:
+            list[list[float]]: List of bboxes in [x, y, w, h] format.
+        """
+        contours, _ = cv.findContours(np_mask, cv.RETR_TREE, cv.CHAIN_APPROX_SIMPLE)
+        boxes = []
+        for contour in contours:
+            contours_poly = cv.approxPolyDP(contour, 3, True)
+            x, y, w, h = cv.boundingRect(contours_poly)
+            bbox_area = w * h
+            if bbox_area > self.attributes.anomaly_area_threshold:
+                boxes.append([x, y, w, h])
+        return boxes
+
+    def process_packet(self, data_packet: ImagePacket) -> None:
+        """Process an individual image packet through the inference pipeline.
+
+        Args:
+            data_packet (ImagePacket): The image packet containing the image to process
+        """
+        image = deepcopy(data_packet.content)
+        processed_image = self.transform(image)
+        result = self.inferencer.predict(processed_image)
+
+        label = result.pred_label
+        label_str = AnomalibInferenceKeys.ANOMALOUS if label == LabelName.ABNORMAL else AnomalibInferenceKeys.NORMAL
+
+        pred_score = result.pred_score * 100
+
+        if result.pred_mask is None:
+            annotations = [ImageAnnotations(label=label, label_str=label_str, confidence_score=pred_score)]
+        else:
+            np_mask = self.postprocess_segmentation_mask(result.pred_mask, image)
+
+            boxes = self.get_boxes_from_mask(np_mask)
+
+            annotations = self._create_detection_annotations(
+                boxes=boxes, pred_score=pred_score, label=label, label_str=label_str, pred_mask=np_mask
+            )
+
+        data_packet.annotations = annotations
+
+    @staticmethod
+    def _create_classification_annotation(pred_score: float, label: str, label_str: str) -> ImageAnnotations:
+        """Create classification annotation from prediction results.
+
+        Args:
+            pred_score (float): Confidence score of the prediction (0-100)
+            label (str): Numeric label value
+            label_str (str): String representation of the label
+
+        Returns:
+            ImageAnnotations: Object containing classification results
+        """
+        return ImageAnnotations(
+            label=label,
+            label_str=label_str,
+            confidence_score=pred_score,
+        )
+
+    @staticmethod
+    def _create_detection_annotations(
+        boxes: list[list[float]],
+        pred_score: float,
+        label: int,
+        label_str: str,
+        pred_mask: np.ndarray,
+    ) -> list[ImageAnnotations]:
+        """Create detection annotations from prediction results.
+
+        Args:
+            boxes (list[list[float]]): Array of bounding box coordinates in xyxy format
+            pred_score (float): Confidence score of the prediction (0-100)
+            label (int): Numeric label value
+            label_str (str): String representation of the label
+            pred_mask (np.ndarray): Optional segmentation mask array
+
+        Returns:
+            list[ImageAnnotations]: List of objects containing detection results
+        """
+        annotations = []
+        for box in boxes:
+            x, y, w, h = box
+            bbox = BoundingBox(x=x, y=y, w=w, h=h)
+
+            box_mask = np.zeros_like(pred_mask, dtype=np.uint8)
+            x1, y1 = int(x), int(y)
+            x2, y2 = int(x + w), int(y + h)
+
+            box_mask[y1:y2, x1:x2] = np.where(pred_mask[y1:y2, x1:x2] > 0, 1, 0)
+
+            segmentation = Segmentation(mask=box_mask)
+
+            annotations.append(
+                ImageAnnotations(
+                    label=label,
+                    label_str=label_str,
+                    confidence_score=pred_score,
+                    bbox=bbox,
+                    segmentation=segmentation,
+                )
+            )
+        return annotations
+
+    def execute(self, container: DataContainer) -> DataContainer:
+        """Process all images in the data container through the inference pipeline.
+
+        Args:
+            container (DataContainer): Input data container with images to process
+
+        Returns:
+            DataContainer: The processed data container with inference results
+        """
+        for image_packet in container.images:
+            self.process_packet(image_packet)
+        return container