diff --git a/anomalib/data/__init__.py b/anomalib/data/__init__.py index 21efccb891..c2f3be9b03 100644 --- a/anomalib/data/__init__.py +++ b/anomalib/data/__init__.py @@ -13,8 +13,10 @@ from .base import AnomalibDataModule, AnomalibDataset from .btech import BTech from .folder import Folder +from .folder_3d import Folder3D from .inference import InferenceDataset from .mvtec import MVTec +from .mvtec_3d import MVTec3D from .shanghaitech import ShanghaiTech from .task_type import TaskType from .ucsd_ped import UCSDped @@ -59,6 +61,24 @@ def get_datamodule(config: DictConfig | ListConfig) -> AnomalibDataModule: val_split_mode=config.dataset.val_split_mode, val_split_ratio=config.dataset.val_split_ratio, ) + elif config.dataset.format.lower() == "mvtec_3d": + datamodule = MVTec3D( + root=config.dataset.path, + category=config.dataset.category, + image_size=(config.dataset.image_size[0], config.dataset.image_size[1]), + center_crop=center_crop, + normalization=config.dataset.normalization, + train_batch_size=config.dataset.train_batch_size, + eval_batch_size=config.dataset.eval_batch_size, + num_workers=config.dataset.num_workers, + task=config.dataset.task, + transform_config_train=config.dataset.transform_config.train, + transform_config_eval=config.dataset.transform_config.eval, + test_split_mode=config.dataset.test_split_mode, + test_split_ratio=config.dataset.test_split_ratio, + val_split_mode=config.dataset.val_split_mode, + val_split_ratio=config.dataset.val_split_ratio, + ) elif config.dataset.format.lower() == "btech": datamodule = BTech( root=config.dataset.path, @@ -99,6 +119,31 @@ def get_datamodule(config: DictConfig | ListConfig) -> AnomalibDataModule: val_split_mode=config.dataset.val_split_mode, val_split_ratio=config.dataset.val_split_ratio, ) + elif config.dataset.format.lower() == "folder_3d": + datamodule = Folder3D( + root=config.dataset.root, + normal_dir=config.dataset.normal_dir, + normal_depth_dir=config.dataset.normal_depth_dir, + abnormal_dir=config.dataset.abnormal_dir, + abnormal_depth_dir=config.dataset.abnormal_depth_dir, + task=config.dataset.task, + normal_test_dir=config.dataset.normal_test_dir, + normal_test_depth_dir=config.dataset.normal_test_depth_dir, + mask_dir=config.dataset.mask_dir, + extensions=config.dataset.extensions, + image_size=(config.dataset.image_size[0], config.dataset.image_size[1]), + center_crop=center_crop, + normalization=config.dataset.normalization, + train_batch_size=config.dataset.train_batch_size, + eval_batch_size=config.dataset.eval_batch_size, + num_workers=config.dataset.num_workers, + transform_config_train=config.dataset.transform_config.train, + transform_config_eval=config.dataset.transform_config.eval, + test_split_mode=config.dataset.test_split_mode, + test_split_ratio=config.dataset.test_split_ratio, + val_split_mode=config.dataset.val_split_mode, + val_split_ratio=config.dataset.val_split_ratio, + ) elif config.dataset.format.lower() == "ucsdped": datamodule = UCSDped( root=config.dataset.path, @@ -187,8 +232,10 @@ def get_datamodule(config: DictConfig | ListConfig) -> AnomalibDataModule: "get_datamodule", "BTech", "Folder", + "Folder3D", "InferenceDataset", "MVTec", + "MVTec3D", "Avenue", "UCSDped", "TaskType", diff --git a/anomalib/data/base/__init__.py b/anomalib/data/base/__init__.py index 936388b228..00d67a7ea3 100644 --- a/anomalib/data/base/__init__.py +++ b/anomalib/data/base/__init__.py @@ -6,6 +6,13 @@ from .datamodule import AnomalibDataModule from .dataset import AnomalibDataset +from .depth import AnomalibDepthDataset from .video import AnomalibVideoDataModule, AnomalibVideoDataset -__all__ = ["AnomalibDataset", "AnomalibDataModule", "AnomalibVideoDataset", "AnomalibVideoDataModule"] +__all__ = [ + "AnomalibDataset", + "AnomalibDataModule", + "AnomalibVideoDataset", + "AnomalibVideoDataModule", + "AnomalibDepthDataset", +] diff --git a/anomalib/data/base/datamodule.py b/anomalib/data/base/datamodule.py index f8ed1e42bc..47da8a410a 100644 --- a/anomalib/data/base/datamodule.py +++ b/anomalib/data/base/datamodule.py @@ -12,7 +12,7 @@ from pandas import DataFrame from pytorch_lightning import LightningDataModule from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS -from torch.utils.data import DataLoader, default_collate +from torch.utils.data.dataloader import DataLoader, default_collate from anomalib.data.base.dataset import AnomalibDataset from anomalib.data.synthetic import SyntheticAnomalyDataset diff --git a/anomalib/data/base/dataset.py b/anomalib/data/base/dataset.py index b0e3f70da9..3a4a14798a 100644 --- a/anomalib/data/base/dataset.py +++ b/anomalib/data/base/dataset.py @@ -126,6 +126,7 @@ def __getitem__(self, index: int) -> dict[str, str | Tensor]: elif self.task in (TaskType.DETECTION, TaskType.SEGMENTATION): # Only Anomalous (1) images have masks in anomaly datasets # Therefore, create empty mask for Normal (0) images. + if label_index == 0: mask = np.zeros(shape=image.shape[:2]) else: diff --git a/anomalib/data/base/depth.py b/anomalib/data/base/depth.py new file mode 100644 index 0000000000..f495342926 --- /dev/null +++ b/anomalib/data/base/depth.py @@ -0,0 +1,68 @@ +"""Base Depth Dataset.""" + +from __future__ import annotations + +from abc import ABC + +import albumentations as A +import cv2 +import numpy as np +from torch import Tensor + +from anomalib.data.base.dataset import AnomalibDataset +from anomalib.data.task_type import TaskType +from anomalib.data.utils import masks_to_boxes, read_depth_image, read_image + + +class AnomalibDepthDataset(AnomalibDataset, ABC): + """Base depth anomalib dataset class. + + Args: + task (str): Task type, either 'classification' or 'segmentation' + transform (A.Compose): Albumentations Compose object describing the transforms that are applied to the inputs. + """ + + def __init__(self, task: TaskType, transform: A.Compose) -> None: + super().__init__(task, transform) + + self.transform = transform + + def __getitem__(self, index: int) -> dict[str, str | Tensor]: + """Return rgb image, depth image and mask.""" + + image_path = self._samples.iloc[index].image_path + mask_path = self._samples.iloc[index].mask_path + label_index = self._samples.iloc[index].label_index + depth_path = self._samples.iloc[index].depth_path + + image = read_image(image_path) + depth_image = read_depth_image(depth_path) + item = dict(image_path=image_path, depth_path=depth_path, label=label_index) + + if self.task == TaskType.CLASSIFICATION: + transformed = self.transform(image=image, depth_image=depth_image) + item["image"] = transformed["image"] + item["depth_image"] = transformed["depth_image"] + elif self.task in (TaskType.DETECTION, TaskType.SEGMENTATION): + # Only Anomalous (1) images have masks in anomaly datasets + # Therefore, create empty mask for Normal (0) images. + if label_index == 0: + mask = np.zeros(shape=image.shape[:2]) + else: + mask = cv2.imread(mask_path, flags=0) / 255.0 + + transformed = self.transform(image=image, depth_image=depth_image, mask=mask) + + item["image"] = transformed["image"] + item["depth_image"] = transformed["depth_image"] + item["mask_path"] = mask_path + item["mask"] = transformed["mask"] + + if self.task == TaskType.DETECTION: + # create boxes from masks for detection task + boxes, _ = masks_to_boxes(item["mask"]) + item["boxes"] = boxes[0] + else: + raise ValueError(f"Unknown task type: {self.task}") + + return item diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index d0a7892abc..8d64974af8 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -12,7 +12,6 @@ import albumentations as A from pandas import DataFrame -from torchvision.datasets.folder import IMG_EXTENSIONS from anomalib.data.base import AnomalibDataModule, AnomalibDataset from anomalib.data.task_type import TaskType @@ -23,74 +22,7 @@ ValSplitMode, get_transforms, ) - - -def _check_and_convert_path(path: str | Path) -> Path: - """Check an input path, and convert to Pathlib object. - - Args: - path (str | Path): Input path. - - Returns: - Path: Output path converted to pathlib object. - """ - if not isinstance(path, Path): - path = Path(path) - return path - - -def _prepare_files_labels( - path: str | Path, path_type: str, extensions: tuple[str, ...] | None = None -) -> tuple[list, list]: - """Return a list of filenames and list corresponding labels. - - Args: - path (str | Path): Path to the directory containing images. - path_type (str): Type of images in the provided path ("normal", "abnormal", "normal_test") - extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the - directory. - - Returns: - List, List: Filenames of the images provided in the paths, labels of the images provided in the paths - """ - path = _check_and_convert_path(path) - if extensions is None: - extensions = IMG_EXTENSIONS - - if isinstance(extensions, str): - extensions = (extensions,) - - filenames = [f for f in path.glob(r"**/*") if f.suffix in extensions and not f.is_dir()] - if not filenames: - raise RuntimeError(f"Found 0 {path_type} images in {path}") - - labels = [path_type] * len(filenames) - - return filenames, labels - - -def _resolve_path(folder: str | Path, root: str | Path | None = None) -> Path: - """Combines root and folder and returns the absolute path. - - This allows users to pass either a root directory and relative paths, or absolute paths to each of the - image sources. This function makes sure that the samples dataframe always contains absolute paths. - - Args: - folder (str | Path | None): Folder location containing image or mask data. - root (str | Path | None): Root directory for the dataset. - """ - folder = Path(folder) - if folder.is_absolute(): - # path is absolute; return unmodified - path = folder - # path is relative. - elif root is None: - # no root provided; return absolute path - path = folder.resolve() - else: - # root provided; prepend root and return absolute path - path = (Path(root) / folder).resolve() - return path +from anomalib.data.utils.path import _prepare_files_labels, _resolve_path def make_folder_dataset( @@ -137,31 +69,42 @@ def make_folder_dataset( if normal_test_dir: dirs = {**dirs, **{"normal_test": normal_test_dir}} + if mask_dir: + dirs = {**dirs, **{"mask_dir": mask_dir}} + for dir_type, path in dirs.items(): filename, label = _prepare_files_labels(path, dir_type, extensions) filenames += filename labels += label - samples = DataFrame({"image_path": filenames, "label": labels, "mask_path": ""}) + samples = DataFrame({"image_path": filenames, "label": labels}) + samples = samples.sort_values(by="image_path", ignore_index=True) # Create label index for normal (0) and abnormal (1) images. samples.loc[(samples.label == "normal") | (samples.label == "normal_test"), "label_index"] = 0 samples.loc[(samples.label == "abnormal"), "label_index"] = 1 - samples.label_index = samples.label_index.astype(int) + samples.label_index = samples.label_index.astype("Int64") # If a path to mask is provided, add it to the sample dataframe. if mask_dir is not None: - mask_dir = _check_and_convert_path(mask_dir) - for index, row in samples.iterrows(): - if row.label_index == 1: - rel_image_path = row.image_path.relative_to(abnormal_dir) - samples.loc[index, "mask_path"] = str(mask_dir / rel_image_path) - - # make sure all the files exist - # samples.image_path does NOT need to be checked because we build the df based on that - assert samples.mask_path.apply( - lambda x: Path(x).exists() if x != "" else True - ).all(), f"missing mask files, mask_dir={mask_dir}" + samples.loc[samples.label == "abnormal", "mask_path"] = samples.loc[ + samples.label == "mask_dir" + ].image_path.values + samples = samples.astype({"mask_path": "str"}) + + # make sure all every rgb image has a corresponding mask image. + assert ( + samples.loc[samples.label_index == 1] + .apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1) + .all() + ), "Mismatch between anomalous images and mask images. Make sure the mask files \ + folder follow the same naming convention as the anomalous images in the dataset \ + (e.g. image: '000.png', mask: '000.png')." + + # remove all the rows with temporal image samples that have already been assigned + samples = samples.loc[ + (samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test") + ] # Ensure the pathlib objects are converted to str. # This is because torch dataloader doesn't like pathlib. diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py new file mode 100644 index 0000000000..d4c7f8f1f6 --- /dev/null +++ b/anomalib/data/folder_3d.py @@ -0,0 +1,376 @@ +"""Custom Folder Dataset. + +This script creates a custom dataset from a folder. +""" + +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +from pathlib import Path + +import albumentations as A +from pandas import DataFrame, isna + +from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset +from anomalib.data.task_type import TaskType +from anomalib.data.utils import ( + InputNormalizationMethod, + Split, + TestSplitMode, + ValSplitMode, + get_transforms, +) +from anomalib.data.utils.path import _prepare_files_labels, _resolve_path + + +def make_folder3d_dataset( + normal_dir: str | Path, + root: str | Path | None = None, + abnormal_dir: str | Path | None = None, + normal_test_dir: str | Path | None = None, + mask_dir: str | Path | None = None, + normal_depth_dir: str | Path | None = None, + abnormal_depth_dir: str | Path | None = None, + normal_test_depth_dir: str | Path | None = None, + split: str | Split | None = None, + extensions: tuple[str, ...] | None = None, +) -> DataFrame: + """Make Folder Dataset. + + Args: + normal_dir (str | Path): Path to the directory containing normal images. + root (str | Path | None): Path to the root directory of the dataset. + abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images. + normal_test_dir (str | Path | None, optional): Path to the directory containing + normal images for the test dataset. Normal test images will be a split of `normal_dir` + if `None`. Defaults to None. + mask_dir (str | Path | None, optional): Path to the directory containing + the mask annotations. Defaults to None. + normal_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir` + abnormal_depth_dir (str | Path | None, optional): Path to the directory containing + abnormal depth images for the test dataset. + normal_test_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test images will be a split of `normal_dir` + if `None`. Defaults to None. + split (str | Split | None, optional): Dataset split (ie., Split.FULL, Split.TRAIN or Split.TEST). + Defaults to None. + extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the + directory. + + Returns: + DataFrame: an output dataframe containing samples for the requested split (ie., train or test) + """ + normal_dir = _resolve_path(normal_dir, root) + abnormal_dir = _resolve_path(abnormal_dir, root) if abnormal_dir is not None else None + normal_test_dir = _resolve_path(normal_test_dir, root) if normal_test_dir is not None else None + mask_dir = _resolve_path(mask_dir, root) if mask_dir is not None else None + normal_depth_dir = _resolve_path(normal_depth_dir, root) if normal_depth_dir is not None else None + abnormal_depth_dir = _resolve_path(abnormal_depth_dir, root) if abnormal_depth_dir is not None else None + normal_test_depth_dir = _resolve_path(normal_test_depth_dir, root) if normal_test_depth_dir is not None else None + + assert normal_dir.is_dir(), "A folder location must be provided in normal_dir." + + filenames = [] + labels = [] + dirs = {"normal": normal_dir} + + if abnormal_dir: + dirs = {**dirs, **{"abnormal": abnormal_dir}} + + if normal_test_dir: + dirs = {**dirs, **{"normal_test": normal_test_dir}} + + if normal_depth_dir: + dirs = {**dirs, **{"normal_depth": normal_depth_dir}} + + if abnormal_depth_dir: + dirs = {**dirs, **{"abnormal_depth": abnormal_depth_dir}} + + if normal_test_depth_dir: + dirs = {**dirs, **{"normal_test_depth": normal_test_depth_dir}} + + if mask_dir: + dirs = {**dirs, **{"mask_dir": mask_dir}} + + for dir_type, path in dirs.items(): + filename, label = _prepare_files_labels(path, dir_type, extensions) + filenames += filename + labels += label + + samples = DataFrame({"image_path": filenames, "label": labels}) + samples = samples.sort_values(by="image_path", ignore_index=True) + + # Create label index for normal (0) and abnormal (1) images. + samples.loc[(samples.label == "normal") | (samples.label == "normal_test"), "label_index"] = 0 + samples.loc[(samples.label == "abnormal"), "label_index"] = 1 + samples.label_index = samples.label_index.astype("Int64") + + # If a path to mask is provided, add it to the sample dataframe. + if normal_depth_dir is not None: + samples.loc[samples.label == "normal", "depth_path"] = samples.loc[ + samples.label == "normal_depth" + ].image_path.values + samples.loc[samples.label == "abnormal", "depth_path"] = samples.loc[ + samples.label == "abnormal_depth" + ].image_path.values + + if normal_test_dir is not None: + samples.loc[samples.label == "normal_test", "depth_path"] = samples.loc[ + samples.label == "normal_test_depth" + ].image_path.values + + # make sure every rgb image has a corresponding depth image and that the file exists + assert ( + samples.loc[samples.label_index == 1] + .apply(lambda x: Path(x.image_path).stem in Path(x.depth_path).stem, axis=1) + .all() + ), "Mismatch between anomalous images and depth images. Make sure the mask files in 'xyz' \ + folder follow the same naming convention as the anomalous images in the dataset \ + (e.g. image: '000.png', depth: '000.tiff')." + + assert samples.depth_path.apply( + lambda x: Path(x).exists() if not isna(x) else True + ).all(), "missing depth image files" + + samples = samples.astype({"depth_path": "str"}) + + # If a path to mask is provided, add it to the sample dataframe. + if mask_dir is not None: + samples.loc[samples.label == "abnormal", "mask_path"] = samples.loc[ + samples.label == "mask_dir" + ].image_path.values + samples = samples.astype({"mask_path": "str"}) + + # make sure all the files exist + assert samples.mask_path.apply( + lambda x: Path(x).exists() if x != "" else True + ).all(), f"missing mask files, mask_dir={mask_dir}" + + # remove all the rows with temporal image samples that have already been assigned + samples = samples.loc[ + (samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test") + ] + + # Ensure the pathlib objects are converted to str. + # This is because torch dataloader doesn't like pathlib. + samples = samples.astype({"image_path": "str"}) + + # Create train/test split. + # By default, all the normal samples are assigned as train. + # and all the abnormal samples are test. + samples.loc[(samples.label == "normal"), "split"] = "train" + samples.loc[(samples.label == "abnormal") | (samples.label == "normal_test"), "split"] = "test" + + # Get the data frame for the split. + if split: + samples = samples[samples.split == split] + samples = samples.reset_index(drop=True) + + return samples + + +class Folder3DDataset(AnomalibDepthDataset): + """Folder dataset. + + Args: + task (TaskType): Task type. (``classification``, ``detection`` or ``segmentation``). + transform (A.Compose): Albumentations Compose object describing the transforms that are applied to the inputs. + split (str | Split | None): Fixed subset split that follows from folder structure on file system. + Choose from [Split.FULL, Split.TRAIN, Split.TEST] + normal_dir (str | Path): Path to the directory containing normal images. + root (str | Path | None): Root folder of the dataset. + abnormal_dir (str | Path | None, optional): Path to the directory containing abnormal images. + normal_test_dir (str | Path | None, optional): Path to the directory containing + normal images for the test dataset. Defaults to None. + mask_dir (str | Path | None, optional): Path to the directory containing + the mask annotations. Defaults to None. + normal_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir` + abnormal_depth_dir (str | Path | None, optional): Path to the directory containing + abnormal depth images for the test dataset. + normal_test_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test images will be a split of `normal_dir` + if `None`. Defaults to None. + extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the + directory. + val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained. + + Raises: + ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is + provided, `task` should be set to `segmentation`. + """ + + def __init__( + self, + task: TaskType, + transform: A.Compose, + normal_dir: str | Path, + root: str | Path | None = None, + abnormal_dir: str | Path | None = None, + normal_test_dir: str | Path | None = None, + mask_dir: str | Path | None = None, + normal_depth_dir: str | Path | None = None, + abnormal_depth_dir: str | Path | None = None, + normal_test_depth_dir: str | Path | None = None, + split: str | Split | None = None, + extensions: tuple[str, ...] | None = None, + ) -> None: + super().__init__(task, transform) + + self.split = split + self.root = root + self.normal_dir = normal_dir + self.abnormal_dir = abnormal_dir + self.normal_test_dir = normal_test_dir + self.mask_dir = mask_dir + self.normal_depth_dir = normal_depth_dir + self.abnormal_depth_dir = abnormal_depth_dir + self.normal_test_depth_dir = normal_test_depth_dir + self.extensions = extensions + + def _setup(self) -> None: + """Assign samples.""" + self.samples = make_folder3d_dataset( + root=self.root, + normal_dir=self.normal_dir, + abnormal_dir=self.abnormal_dir, + normal_test_dir=self.normal_test_dir, + mask_dir=self.mask_dir, + normal_depth_dir=self.normal_depth_dir, + abnormal_depth_dir=self.abnormal_depth_dir, + normal_test_depth_dir=self.normal_test_depth_dir, + split=self.split, + extensions=self.extensions, + ) + + +class Folder3D(AnomalibDataModule): + """Folder DataModule. + + Args: + normal_dir (str | Path): Name of the directory containing normal images. + Defaults to "normal". + root (str | Path | None): Path to the root folder containing normal and abnormal dirs. + abnormal_dir (str | Path | None): Name of the directory containing abnormal images. + Defaults to "abnormal". + normal_test_dir (str | Path | None, optional): Path to the directory containing + normal images for the test dataset. Defaults to None. + mask_dir (str | Path | None, optional): Path to the directory containing + the mask annotations. Defaults to None. + normal_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test depth images will be a split of `normal_dir` + abnormal_depth_dir (str | Path | None, optional): Path to the directory containing + abnormal depth images for the test dataset. + normal_test_depth_dir (str | Path | None, optional): Path to the directory containing + normal depth images for the test dataset. Normal test images will be a split of `normal_dir` + if `None`. Defaults to None. + normal_split_ratio (float, optional): Ratio to split normal training images and add to the + test set in case test set doesn't contain any normal images. + Defaults to 0.2. + extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the + directory. Defaults to None. + image_size (int | tuple[int, int] | None, optional): Size of the input image. + Defaults to None. + center_crop (int | tuple[int, int] | None, optional): When provided, the images will be center-cropped + to the provided dimensions. + normalize (bool): When True, the images will be normalized to the ImageNet statistics. + train_batch_size (int, optional): Training batch size. Defaults to 32. + test_batch_size (int, optional): Test batch size. Defaults to 32. + num_workers (int, optional): Number of workers. Defaults to 8. + task (TaskType, optional): Task type. Could be ``classification``, ``detection`` or ``segmentation``. + Defaults to segmentation. + transform_config_train (str | A.Compose | None, optional): Config for pre-processing + during training. + Defaults to None. + transform_config_val (str | A.Compose | None, optional): Config for pre-processing + during validation. + Defaults to None. + test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained. + test_split_ratio (float): Fraction of images from the train set that will be reserved for testing. + val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained. + val_split_ratio (float): Fraction of train or test images that will be reserved for validation. + seed (int | None, optional): Seed used during random subset splitting. + """ + + def __init__( + self, + normal_dir: str | Path, + root: str | Path | None = None, + abnormal_dir: str | Path | None = None, + normal_test_dir: str | Path | None = None, + mask_dir: str | Path | None = None, + normal_depth_dir: str | Path | None = None, + abnormal_depth_dir: str | Path | None = None, + normal_test_depth_dir: str | Path | None = None, + extensions: tuple[str] | None = None, + image_size: int | tuple[int, int] | None = None, + center_crop: int | tuple[int, int] | None = None, + normalization: str | InputNormalizationMethod = InputNormalizationMethod.IMAGENET, + train_batch_size: int = 32, + eval_batch_size: int = 32, + num_workers: int = 8, + task: TaskType = TaskType.SEGMENTATION, + transform_config_train: str | A.Compose | None = None, + transform_config_eval: str | A.Compose | None = None, + test_split_mode: TestSplitMode = TestSplitMode.FROM_DIR, + test_split_ratio: float = 0.2, + val_split_mode: ValSplitMode = ValSplitMode.FROM_TEST, + val_split_ratio: float = 0.5, + seed: int | None = None, + ) -> None: + super().__init__( + train_batch_size=train_batch_size, + eval_batch_size=eval_batch_size, + num_workers=num_workers, + test_split_mode=test_split_mode, + test_split_ratio=test_split_ratio, + val_split_mode=val_split_mode, + val_split_ratio=val_split_ratio, + seed=seed, + ) + + transform_train = get_transforms( + config=transform_config_train, + image_size=image_size, + center_crop=center_crop, + normalization=InputNormalizationMethod(normalization), + ) + transform_eval = get_transforms( + config=transform_config_eval, + image_size=image_size, + center_crop=center_crop, + normalization=InputNormalizationMethod(normalization), + ) + + self.train_data = Folder3DDataset( + task=task, + transform=transform_train, + split=Split.TRAIN, + root=root, + normal_dir=normal_dir, + abnormal_dir=abnormal_dir, + normal_test_dir=normal_test_dir, + mask_dir=mask_dir, + normal_depth_dir=normal_depth_dir, + abnormal_depth_dir=abnormal_depth_dir, + normal_test_depth_dir=normal_test_depth_dir, + extensions=extensions, + ) + + self.test_data = Folder3DDataset( + task=task, + transform=transform_eval, + split=Split.TEST, + root=root, + normal_dir=normal_dir, + abnormal_dir=abnormal_dir, + normal_test_dir=normal_test_dir, + normal_depth_dir=normal_depth_dir, + abnormal_depth_dir=abnormal_depth_dir, + normal_test_depth_dir=normal_test_depth_dir, + mask_dir=mask_dir, + extensions=extensions, + ) diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py new file mode 100644 index 0000000000..6cf6369202 --- /dev/null +++ b/anomalib/data/mvtec_3d.py @@ -0,0 +1,293 @@ +"""MVTec 3D-AD Dataset (CC BY-NC-SA 4.0). + +Description: + This script contains PyTorch Dataset, Dataloader and PyTorch + Lightning DataModule for the MVTec 3D-AD dataset. + If the dataset is not on the file system, the script downloads and + extracts the dataset and create PyTorch data objects. +License: + MVTec 3D-AD dataset is released under the Creative Commons + Attribution-NonCommercial-ShareAlike 4.0 International License + (CC BY-NC-SA 4.0)(https://creativecommons.org/licenses/by-nc-sa/4.0/). +Reference: + - Paul Bergmann, Xin Jin, David Sattlegger, Carsten Steger: + The MVTec 3D-AD Dataset for Unsupervised 3D Anomaly Detection and Localization + in: Proceedings of the 17th International Joint Conference on Computer Vision, Imaging + and Computer Graphics Theory and Applications - Volume 5: VISAPP, 202-213, 2022, + DOI: 10.5220/0010865000003124. +""" + +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +import logging +from pathlib import Path +from typing import Sequence + +import albumentations as A +from pandas import DataFrame + +from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset +from anomalib.data.task_type import TaskType +from anomalib.data.utils import ( + DownloadInfo, + InputNormalizationMethod, + Split, + TestSplitMode, + ValSplitMode, + download_and_extract, + get_transforms, +) + +logger = logging.getLogger(__name__) + + +IMG_EXTENSIONS = [".png", ".PNG", ".tiff"] + +DOWNLOAD_INFO = DownloadInfo( + name="mvtec_3d", + url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832" + "/mvtec_3d_anomaly_detection.tar.xz", + hash="d8bb2800fbf3ac88e798da6ae10dc819", +) + + +def make_mvtec_3d_dataset( + root: str | Path, split: str | Split | None = None, extensions: Sequence[str] | None = None +) -> DataFrame: + """Create MVTec 3D-AD samples by parsing the MVTec AD data file structure. + + The files are expected to follow the structure: + path/to/dataset/split/category/image_filename.png + path/to/dataset/ground_truth/category/mask_filename.png + + This function creates a dataframe to store the parsed information based on the following format: + |---|---------------|-------|---------|---------------|---------------------------------------|-------------| + | | path | split | label | image_path | mask_path | label_index | + |---|---------------|-------|---------|---------------|---------------------------------------|-------------| + | 0 | datasets/name | test | defect | filename.png | ground_truth/defect/filename_mask.png | 1 | + |---|---------------|-------|---------|---------------|---------------------------------------|-------------| + + Args: + path (Path): Path to dataset + split (str | Split | None, optional): Dataset split (ie., either train or test). Defaults to None. + split_ratio (float, optional): Ratio to split normal training images and add to the + test set in case test set doesn't contain any normal images. + Defaults to 0.1. + seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0. + create_validation_set (bool, optional): Boolean to create a validation set from the test set. + MVTec AD dataset does not contain a validation set. Those wanting to create a validation set + could set this flag to ``True``. + + Examples: + The following example shows how to get training samples from MVTec 3D-AD bagel category: + + >>> root = Path('./MVTec3D') + >>> category = 'bagel' + >>> path = root / category + >>> path + PosixPath('MVTec3D/bagel') + + >>> samples = make_mvtec_3d_dataset(path, split='train', split_ratio=0.1, seed=0) + >>> samples.head() + path split label image_path mask_path + 0 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/105.png MVTec3D/bagel/ground_truth/good/gt/105.png + 1 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/017.png MVTec3D/bagel/ground_truth/good/gt/017.png + 2 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/137.png MVTec3D/bagel/ground_truth/good/gt/137.png + 3 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/152.png MVTec3D/bagel/ground_truth/good/gt/152.png + 4 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/109.png MVTec3D/bagel/ground_truth/good/gt/109.png + depth_path label_index + MVTec3D/bagel/ground_truth/good/xyz/105.tiff 0 + MVTec3D/bagel/ground_truth/good/xyz/017.tiff 0 + MVTec3D/bagel/ground_truth/good/xyz/137.tiff 0 + MVTec3D/bagel/ground_truth/good/xyz/152.tiff 0 + MVTec3D/bagel/ground_truth/good/xyz/109.tiff 0 + + Returns: + DataFrame: an output dataframe containing the samples of the dataset. + """ + if extensions is None: + extensions = IMG_EXTENSIONS + + root = Path(root) + samples_list = [(str(root),) + f.parts[-4:] for f in root.glob(r"**/*") if f.suffix in extensions] + if not samples_list: + raise RuntimeError(f"Found 0 images in {root}") + + samples = DataFrame(samples_list, columns=["path", "split", "label", "type", "file_name"]) + + # Modify image_path column by converting to absolute path + samples.loc[(samples.type == "rgb"), "image_path"] = ( + samples.path + "/" + samples.split + "/" + samples.label + "/" + "rgb/" + samples.file_name + ) + samples.loc[(samples.type == "rgb"), "depth_path"] = ( + samples.path + + "/" + + samples.split + + "/" + + samples.label + + "/" + + "xyz/" + + samples.file_name.str.split(".").str[0] + + ".tiff" + ) + + # Create label index for normal (0) and anomalous (1) images. + samples.loc[(samples.label == "good"), "label_index"] = 0 + samples.loc[(samples.label != "good"), "label_index"] = 1 + samples.label_index = samples.label_index.astype(int) + + # separate masks from samples + mask_samples = samples.loc[((samples.split == "test") & (samples.type == "rgb"))].sort_values( + by="image_path", ignore_index=True + ) + samples = samples.sort_values(by="image_path", ignore_index=True) + + # assign mask paths to all test images + samples.loc[((samples.split == "test") & (samples.type == "rgb")), "mask_path"] = ( + mask_samples.path + "/" + samples.split + "/" + samples.label + "/" + "gt/" + samples.file_name + ) + samples.dropna(subset=["image_path"], inplace=True) + samples = samples.astype({"image_path": "str", "mask_path": "str", "depth_path": "str"}) + + # assert that the right mask files are associated with the right test images + assert ( + samples.loc[samples.label_index == 1] + .apply(lambda x: Path(x.image_path).stem in Path(x.mask_path).stem, axis=1) + .all() + ), "Mismatch between anomalous images and ground truth masks. Make sure the mask files in 'ground_truth' \ + folder follow the same naming convention as the anomalous images in the dataset (e.g. image: '000.png', \ + mask: '000.png' or '000_mask.png')." + + # assert that the right depth image files are associated with the right test images + assert ( + samples.loc[samples.label_index == 1] + .apply(lambda x: Path(x.image_path).stem in Path(x.depth_path).stem, axis=1) + .all() + ), "Mismatch between anomalous images and depth images. Make sure the mask files in 'xyz' \ + folder follow the same naming convention as the anomalous images in the dataset (e.g. image: '000.png', \ + depth: '000.tiff')." + + if split: + samples = samples[samples.split == split].reset_index(drop=True) + + return samples + + +class MVTec3DDataset(AnomalibDepthDataset): + """MVTec 3D dataset class. + + Args: + task (TaskType): Task type, ``classification``, ``detection`` or ``segmentation`` + transform (A.Compose): Albumentations Compose object describing the transforms that are applied to the inputs. + split (str | Split | None): Split of the dataset, usually Split.TRAIN or Split.TEST + root (Path | str): Path to the root of the dataset + category (str): Sub-category of the dataset, e.g. 'bagel' + """ + + def __init__( + self, + task: TaskType, + transform: A.Compose, + root: Path | str, + category: str, + split: str | Split | None = None, + ) -> None: + super().__init__(task=task, transform=transform) + + self.root_category = Path(root) / Path(category) + self.split = split + + def _setup(self) -> None: + self.samples = make_mvtec_3d_dataset(self.root_category, split=self.split, extensions=IMG_EXTENSIONS) + + +class MVTec3D(AnomalibDataModule): + """MVTec Datamodule. + + Args: + root (Path | str): Path to the root of the dataset + category (str): Category of the MVTec dataset (e.g. "bottle" or "cable"). + image_size (int | tuple[int, int] | None, optional): Size of the input image. + Defaults to None. + center_crop (int | tuple[int, int] | None, optional): When provided, the images will be center-cropped + to the provided dimensions. + normalize (bool): When True, the images will be normalized to the ImageNet statistics. + train_batch_size (int, optional): Training batch size. Defaults to 32. + eval_batch_size (int, optional): Test batch size. Defaults to 32. + num_workers (int, optional): Number of workers. Defaults to 8. + task TaskType): Task type, 'classification', 'detection' or 'segmentation' + transform_config_train (str | A.Compose | None, optional): Config for pre-processing + during training. + Defaults to None. + transform_config_val (str | A.Compose | None, optional): Config for pre-processing + during validation. + Defaults to None. + test_split_mode (TestSplitMode): Setting that determines how the testing subset is obtained. + test_split_ratio (float): Fraction of images from the train set that will be reserved for testing. + val_split_mode (ValSplitMode): Setting that determines how the validation subset is obtained. + val_split_ratio (float): Fraction of train or test images that will be reserved for validation. + seed (int | None, optional): Seed which may be set to a fixed value for reproducibility. + """ + + def __init__( + self, + root: Path | str, + category: str, + image_size: int | tuple[int, int] | None = None, + center_crop: int | tuple[int, int] | None = None, + normalization: str | InputNormalizationMethod = InputNormalizationMethod.IMAGENET, + train_batch_size: int = 32, + eval_batch_size: int = 32, + num_workers: int = 8, + task: TaskType = TaskType.SEGMENTATION, + transform_config_train: str | A.Compose | None = None, + transform_config_eval: str | A.Compose | None = None, + test_split_mode: TestSplitMode = TestSplitMode.FROM_DIR, + test_split_ratio: float = 0.2, + val_split_mode: ValSplitMode = ValSplitMode.SAME_AS_TEST, + val_split_ratio: float = 0.5, + seed: int | None = None, + ) -> None: + super().__init__( + train_batch_size=train_batch_size, + eval_batch_size=eval_batch_size, + num_workers=num_workers, + test_split_mode=test_split_mode, + test_split_ratio=test_split_ratio, + val_split_mode=val_split_mode, + val_split_ratio=val_split_ratio, + seed=seed, + ) + + self.root = Path(root) + self.category = Path(category) + + transform_train = get_transforms( + config=transform_config_train, + image_size=image_size, + center_crop=center_crop, + normalization=InputNormalizationMethod(normalization), + ) + transform_eval = get_transforms( + config=transform_config_eval, + image_size=image_size, + center_crop=center_crop, + normalization=InputNormalizationMethod(normalization), + ) + + self.train_data = MVTec3DDataset( + task=task, transform=transform_train, split=Split.TRAIN, root=root, category=category + ) + self.test_data = MVTec3DDataset( + task=task, transform=transform_eval, split=Split.TEST, root=root, category=category + ) + + def prepare_data(self) -> None: + """Download the dataset if not available.""" + if (self.root / self.category).is_dir(): + logger.info("Found the dataset.") + else: + download_and_extract(self.root, DOWNLOAD_INFO) diff --git a/anomalib/data/utils/__init__.py b/anomalib/data/utils/__init__.py index 2fa61f72c7..bbd8ac6689 100644 --- a/anomalib/data/utils/__init__.py +++ b/anomalib/data/utils/__init__.py @@ -11,8 +11,10 @@ generate_output_image_filename, get_image_filenames, get_image_height_and_width, + read_depth_image, read_image, ) +from .path import _check_and_convert_path, _prepare_files_labels, _resolve_path from .split import ( Split, TestSplitMode, @@ -29,6 +31,7 @@ "get_image_height_and_width", "random_2d_perlin", "read_image", + "read_depth_image", "random_split", "split_by_label", "concatenate_datasets", @@ -43,4 +46,7 @@ "InputNormalizationMethod", "download_and_extract", "DownloadInfo", + "_check_and_convert_path", + "_prepare_files_labels", + "_resolve_path", ] diff --git a/anomalib/data/utils/image.py b/anomalib/data/utils/image.py index 9b18ff1c58..a49cfe2c54 100644 --- a/anomalib/data/utils/image.py +++ b/anomalib/data/utils/image.py @@ -11,6 +11,7 @@ import cv2 import numpy as np +import tifffile as tiff import torch.nn.functional as F from torch import Tensor from torchvision.datasets.folder import IMG_EXTENSIONS @@ -206,6 +207,24 @@ def read_image(path: str | Path, image_size: int | tuple[int, int] | None = None return image +def read_depth_image(path: str | Path) -> np.ndarray: + """Read tiff depth image from disk. + + Args: + path (str, Path): path to the image file + + Example: + >>> image = read_depth_image("test_image.tiff") + + Returns: + image as numpy array + """ + path = path if isinstance(path, str) else str(path) + image = tiff.imread(path) + + return image + + def pad_nextpow2(batch: Tensor) -> Tensor: """Compute required padding from input size and return padded images. diff --git a/anomalib/data/utils/path.py b/anomalib/data/utils/path.py new file mode 100644 index 0000000000..8ad38da150 --- /dev/null +++ b/anomalib/data/utils/path.py @@ -0,0 +1,78 @@ +"""Path Utils.""" + +# Copyright (C) 2022 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 + +from __future__ import annotations + +from pathlib import Path + +from torchvision.datasets.folder import IMG_EXTENSIONS + + +def _check_and_convert_path(path: str | Path) -> Path: + """Check an input path, and convert to Pathlib object. + + Args: + path (str | Path): Input path. + + Returns: + Path: Output path converted to pathlib object. + """ + if not isinstance(path, Path): + path = Path(path) + return path + + +def _prepare_files_labels( + path: str | Path, path_type: str, extensions: tuple[str, ...] | None = None +) -> tuple[list, list]: + """Return a list of filenames and list corresponding labels. + + Args: + path (str | Path): Path to the directory containing images. + path_type (str): Type of images in the provided path ("normal", "abnormal", "normal_test") + extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the + directory. + + Returns: + List, List: Filenames of the images provided in the paths, labels of the images provided in the paths + """ + path = _check_and_convert_path(path) + if extensions is None: + extensions = IMG_EXTENSIONS + + if isinstance(extensions, str): + extensions = (extensions,) + + filenames = [f for f in path.glob(r"**/*") if f.suffix in extensions and not f.is_dir()] + if not filenames: + raise RuntimeError(f"Found 0 {path_type} images in {path}") + + labels = [path_type] * len(filenames) + + return filenames, labels + + +def _resolve_path(folder: str | Path, root: str | Path | None = None) -> Path: + """Combines root and folder and returns the absolute path. + + This allows users to pass either a root directory and relative paths, or absolute paths to each of the + image sources. This function makes sure that the samples dataframe always contains absolute paths. + + Args: + folder (str | Path | None): Folder location containing image or mask data. + root (str | Path | None): Root directory for the dataset. + """ + folder = Path(folder) + if folder.is_absolute(): + # path is absolute; return unmodified + path = folder + # path is relative. + elif root is None: + # no root provided; return absolute path + path = folder.resolve() + else: + # root provided; prepend root and return absolute path + path = (Path(root) / folder).resolve() + return path diff --git a/anomalib/data/utils/transform.py b/anomalib/data/utils/transform.py index cbfa3b372b..f14e0f239a 100644 --- a/anomalib/data/utils/transform.py +++ b/anomalib/data/utils/transform.py @@ -124,6 +124,6 @@ def get_transforms( if to_tensor: transforms_list.append(ToTensorV2()) - transforms = A.Compose(transforms_list) + transforms = A.Compose(transforms_list, additional_targets={"image": "image", "depth_image": "image"}) return transforms diff --git a/anomalib/post_processing/visualizer.py b/anomalib/post_processing/visualizer.py index c4b51e0904..ae6c1a604d 100644 --- a/anomalib/post_processing/visualizer.py +++ b/anomalib/post_processing/visualizer.py @@ -161,6 +161,8 @@ def _visualize_full(self, image_result: ImageResult) -> np.ndarray: visualization.add_image(image=image_result.segmentations, title="Segmentation Result") elif self.task == TaskType.CLASSIFICATION: visualization.add_image(image_result.image, title="Image") + if hasattr(image_result, "heat_map"): + visualization.add_image(image_result.heat_map, "Predicted Heat Map") if image_result.pred_label: image_classified = add_anomalous_label(image_result.image, image_result.pred_score) else: diff --git a/docs/source/how_to_guides/notebooks b/docs/source/how_to_guides/notebooks index 32b12ea3a9..fc0b805590 120000 --- a/docs/source/how_to_guides/notebooks +++ b/docs/source/how_to_guides/notebooks @@ -1 +1 @@ -../../../notebooks \ No newline at end of file +../../../notebooks diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb index 977384ffe2..a2e2b26a14 100644 --- a/notebooks/100_datamodules/103_folder.ipynb +++ b/notebooks/100_datamodules/103_folder.ipynb @@ -1,47 +1,10 @@ { "cells": [ { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "## Setting up the Working Directory\n", - "This cell is to ensure we change the directory to anomalib source code to have access to the datasets and config files. We assume that you already went through `001_getting_started.ipynb` and install the required packages." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from pathlib import Path\n", - "\n", - "from git.repo import Repo\n", - "\n", - "current_directory = Path.cwd()\n", - "if current_directory.name == \"100_datamodules\":\n", - " # On the assumption that, the notebook is located in\n", - " # ~/anomalib/notebooks/100_datamodules/\n", - " root_directory = current_directory.parent.parent\n", - "elif current_directory.name == \"anomalib\":\n", - " # This means that the notebook is run from the main anomalib directory.\n", - " root_directory = current_directory\n", - "else:\n", - " # Otherwise, we'll need to clone the anomalib repo to the `current_directory`\n", - " repo = Repo.clone_from(url=\"https://github.com/openvinotoolkit/anomalib.git\", to_path=current_directory)\n", - " root_directory = current_directory / \"anomalib\"\n", - "\n", - "os.chdir(root_directory)\n", - "folder_dataset_root = root_directory / \"datasets\" / \"hazelnut_toy\"" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Use Folder Dataset (for Custom Datasets) via API\n", + "## Folder (for Custom Datasets)\n", "\n", "Here we show how one can utilize custom datasets to train anomalib models. A custom dataset in this model can be of the following types:\n", "\n", @@ -58,26 +21,20 @@ "metadata": {}, "outputs": [], "source": [ - "# pylint: disable=wrong-import-position, wrong-import-order\n", - "# flake8: noqa\n", "import numpy as np\n", "from PIL import Image\n", "from torchvision.transforms import ToPILImage\n", "\n", "from anomalib.data.folder import Folder, FolderDataset\n", - "from anomalib.data.utils import InputNormalizationMethod, get_transforms" + "from anomalib.pre_processing import PreProcessor\n", + "from anomalib.pre_processing.transforms import Denormalize" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### DataModule\n", - "\n", - "Similar to how we created the datamodules for existing benchmarking datasets in the previous tutorials, we can also create an Anomalib datamodule for our custom hazelnut dataset.\n", - "\n", - "In addition to the root folder of the dataset, we now also specify which folder contains the normal images, which folder contains the anomalous images, and which folder contains the ground truth masks for the anomalous images.\n" + "### Torch Dataset" ] }, { @@ -86,27 +43,14 @@ "metadata": {}, "outputs": [], "source": [ - "folder_datamodule = Folder(\n", - " root=folder_dataset_root,\n", - " normal_dir=\"good\",\n", - " abnormal_dir=\"crack\",\n", - " task=\"segmentation\",\n", - " mask_dir=folder_dataset_root / \"mask\" / \"crack\",\n", - " image_size=256,\n", - " normalization=InputNormalizationMethod.NONE, # don't apply normalization, as we want to visualize the images\n", - ")\n", - "folder_datamodule.setup()" + "FolderDataset??" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "# Train images\n", - "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n", - "print(data.keys(), data[\"image\"].shape)" + "To create `FolderDataset` we need to import `pre_process` that applies transforms to the input image." ] }, { @@ -115,239 +59,730 @@ "metadata": {}, "outputs": [], "source": [ - "# Test images\n", - "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n", - "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)" + "PreProcessor??" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 3, "metadata": {}, + "outputs": [], "source": [ - "As can be seen above, creating the dataloaders are pretty straghtforward, which could be directly used for training/testing/inference. We could visualize samples from the dataloaders as well." + "pre_process = PreProcessor(image_size=256, to_tensor=True)" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "img = ToPILImage()(data[\"image\"][0].clone())\n", - "msk = ToPILImage()(data[\"mask\"][0]).convert(\"RGB\")\n", - "\n", - "Image.fromarray(np.hstack((np.array(img), np.array(msk))))" + "#### Classification Task" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 4, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
image_pathlabellabel_indexsplit
0../../datasets/hazelnut_toy/good/08.jpgnormal0train
1../../datasets/hazelnut_toy/good/30.jpgnormal0train
2../../datasets/hazelnut_toy/good/09.jpgnormal0train
3../../datasets/hazelnut_toy/good/25.jpgnormal0train
4../../datasets/hazelnut_toy/good/26.jpgnormal0train
\n", + "
" + ], + "text/plain": [ + " image_path label label_index split\n", + "0 ../../datasets/hazelnut_toy/good/08.jpg normal 0 train\n", + "1 ../../datasets/hazelnut_toy/good/30.jpg normal 0 train\n", + "2 ../../datasets/hazelnut_toy/good/09.jpg normal 0 train\n", + "3 ../../datasets/hazelnut_toy/good/25.jpg normal 0 train\n", + "4 ../../datasets/hazelnut_toy/good/26.jpg normal 0 train" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "`Folder` data module offers much more flexibility cater all different sorts of needs. Please refer to the documentation for more details." + "folder_dataset_classification_train = FolderDataset(\n", + " normal_dir=\"../../datasets/hazelnut_toy/good\",\n", + " abnormal_dir=\"../../datasets/hazelnut_toy/crack\",\n", + " split=\"train\",\n", + " pre_process=pre_process,\n", + ")\n", + "folder_dataset_classification_train.samples.head()" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "### Torch Dataset\n", - "\n", - "As in earlier examples, we can also create a standalone PyTorch dataset instance." + "Let's look at the first sample in the dataset." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(dict_keys(['image']), torch.Size([3, 256, 256]))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "FolderDataset??" + "data = folder_dataset_classification_train[0]\n", + "data.keys(), data[\"image\"].shape" ] }, { - "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "To create `FolderDataset` we need to create the albumentations object that applies transforms to the input image." + "As can be seen above, when we choose `classification` task and `train` split, the dataset only returns `image`. This is mainly because training only requires normal images and no labels. Now let's try `test` split for the `classification` task" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
image_pathlabellabel_indexsplit
0../../datasets/hazelnut_toy/good/33.jpgnormal0test
1../../datasets/hazelnut_toy/good/25.jpgnormal0test
2../../datasets/hazelnut_toy/good/01.jpgnormal0test
3../../datasets/hazelnut_toy/good/02.jpgnormal0test
4../../datasets/hazelnut_toy/good/03.jpgnormal0test
\n", + "
" + ], + "text/plain": [ + " image_path label label_index split\n", + "0 ../../datasets/hazelnut_toy/good/33.jpg normal 0 test\n", + "1 ../../datasets/hazelnut_toy/good/25.jpg normal 0 test\n", + "2 ../../datasets/hazelnut_toy/good/01.jpg normal 0 test\n", + "3 ../../datasets/hazelnut_toy/good/02.jpg normal 0 test\n", + "4 ../../datasets/hazelnut_toy/good/03.jpg normal 0 test" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "get_transforms??" + "# Folder Classification Test Set\n", + "folder_dataset_classification_train = FolderDataset(\n", + " normal_dir=\"../../datasets/hazelnut_toy/good\",\n", + " abnormal_dir=\"../../datasets/hazelnut_toy/crack\",\n", + " split=\"test\",\n", + " pre_process=pre_process,\n", + ")\n", + "folder_dataset_classification_train.samples.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(dict_keys(['image', 'image_path', 'label']),\n", + " torch.Size([3, 256, 256]),\n", + " '../../datasets/hazelnut_toy/good/33.jpg',\n", + " 0)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "image_size = (256, 256)\n", - "transform = get_transforms(image_size=256, normalization=InputNormalizationMethod.NONE)" + "data = folder_dataset_classification_train[0]\n", + "data.keys(), data[\"image\"].shape, data[\"image_path\"], data[\"label\"]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Classification Task" + "#### Segmentation Task\n", + "\n", + "It is also possible to configure the Folder dataset for the segmentation task, where the dataset object returns image and ground-truth mask." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
image_pathlabellabel_indexmask_pathsplit
0../../datasets/hazelnut_toy/good/08.jpgnormal0train
1../../datasets/hazelnut_toy/good/33.jpgnormal0train
2../../datasets/hazelnut_toy/good/30.jpgnormal0train
3../../datasets/hazelnut_toy/good/09.jpgnormal0train
4../../datasets/hazelnut_toy/good/26.jpgnormal0train
\n", + "
" + ], + "text/plain": [ + " image_path label label_index mask_path \\\n", + "0 ../../datasets/hazelnut_toy/good/08.jpg normal 0 \n", + "1 ../../datasets/hazelnut_toy/good/33.jpg normal 0 \n", + "2 ../../datasets/hazelnut_toy/good/30.jpg normal 0 \n", + "3 ../../datasets/hazelnut_toy/good/09.jpg normal 0 \n", + "4 ../../datasets/hazelnut_toy/good/26.jpg normal 0 \n", + "\n", + " split \n", + "0 train \n", + "1 train \n", + "2 train \n", + "3 train \n", + "4 train " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "folder_dataset_classification_train = FolderDataset(\n", - " normal_dir=folder_dataset_root / \"good\",\n", - " abnormal_dir=folder_dataset_root / \"crack\",\n", + "# Folder Segmentation Train Set\n", + "folder_dataset_segmentation_train = FolderDataset(\n", + " normal_dir=\"../../datasets/hazelnut_toy/good\",\n", + " abnormal_dir=\"../../datasets/hazelnut_toy/crack\",\n", " split=\"train\",\n", - " transform=transform,\n", - " task=\"classification\",\n", + " pre_process=pre_process,\n", + " mask_dir=\"../../datasets/hazelnut_toy/mask/crack\",\n", ")\n", - "folder_dataset_classification_train.setup()\n", - "folder_dataset_classification_train.samples.head()" + "folder_dataset_segmentation_train.samples.head()" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 9, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
image_pathlabellabel_indexmask_pathsplit
0../../datasets/hazelnut_toy/good/14.jpgnormal0test
1../../datasets/hazelnut_toy/good/10.jpgnormal0test
2../../datasets/hazelnut_toy/good/29.jpgnormal0test
3../../datasets/hazelnut_toy/good/06.jpgnormal0test
4../../datasets/hazelnut_toy/good/27.jpgnormal0test
5../../datasets/hazelnut_toy/good/32.jpgnormal0test
6../../datasets/hazelnut_toy/crack/01.jpgabnormal1../../datasets/hazelnut_toy/mask/crack/01.jpgtest
7../../datasets/hazelnut_toy/crack/02.jpgabnormal1../../datasets/hazelnut_toy/mask/crack/02.jpgtest
8../../datasets/hazelnut_toy/crack/04.jpgabnormal1../../datasets/hazelnut_toy/mask/crack/04.jpgtest
9../../datasets/hazelnut_toy/crack/03.jpgabnormal1../../datasets/hazelnut_toy/mask/crack/03.jpgtest
\n", + "
" + ], + "text/plain": [ + " image_path label label_index \\\n", + "0 ../../datasets/hazelnut_toy/good/14.jpg normal 0 \n", + "1 ../../datasets/hazelnut_toy/good/10.jpg normal 0 \n", + "2 ../../datasets/hazelnut_toy/good/29.jpg normal 0 \n", + "3 ../../datasets/hazelnut_toy/good/06.jpg normal 0 \n", + "4 ../../datasets/hazelnut_toy/good/27.jpg normal 0 \n", + "5 ../../datasets/hazelnut_toy/good/32.jpg normal 0 \n", + "6 ../../datasets/hazelnut_toy/crack/01.jpg abnormal 1 \n", + "7 ../../datasets/hazelnut_toy/crack/02.jpg abnormal 1 \n", + "8 ../../datasets/hazelnut_toy/crack/04.jpg abnormal 1 \n", + "9 ../../datasets/hazelnut_toy/crack/03.jpg abnormal 1 \n", + "\n", + " mask_path split \n", + "0 test \n", + "1 test \n", + "2 test \n", + "3 test \n", + "4 test \n", + "5 test \n", + "6 ../../datasets/hazelnut_toy/mask/crack/01.jpg test \n", + "7 ../../datasets/hazelnut_toy/mask/crack/02.jpg test \n", + "8 ../../datasets/hazelnut_toy/mask/crack/04.jpg test \n", + "9 ../../datasets/hazelnut_toy/mask/crack/03.jpg test " + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "Let's look at the first sample in the dataset." + "# Folder Segmentation Test Set\n", + "folder_dataset_segmentation_test = FolderDataset(\n", + " normal_dir=\"../../datasets/hazelnut_toy/good\",\n", + " abnormal_dir=\"../../datasets/hazelnut_toy/crack\",\n", + " split=\"test\",\n", + " pre_process=pre_process,\n", + " mask_dir=\"../../datasets/hazelnut_toy/mask/crack\",\n", + " task=\"segmentation\",\n", + ")\n", + "folder_dataset_segmentation_test.samples.head(10)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(dict_keys(['image', 'image_path', 'label', 'mask_path', 'mask']),\n", + " torch.Size([3, 256, 256]),\n", + " torch.Size([256, 256]))" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "data = folder_dataset_classification_train[0]\n", - "print(data.keys(), data[\"image\"].shape)" + "data = folder_dataset_segmentation_test[9]\n", + "data.keys(), data[\"image\"].shape, data[\"mask\"].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As can be seen above, when we choose `classification` task and `train` split, the dataset only returns `image`. This is mainly because training only requires normal images and no labels. Now let's try `test` split for the `classification` task" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Folder Classification Test Set\n", - "folder_dataset_classification_test = FolderDataset(\n", - " normal_dir=folder_dataset_root / \"good\",\n", - " abnormal_dir=folder_dataset_root / \"crack\",\n", - " split=\"test\",\n", - " transform=transform,\n", - " task=\"classification\",\n", - ")\n", - "folder_dataset_classification_test.setup()\n", - "folder_dataset_classification_test.samples.head()" + "Let's visualize the image and the mask..." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "data = folder_dataset_classification_test[0]\n", - "print(data.keys(), data[\"image\"].shape, data[\"image_path\"], data[\"label\"])" + "img = ToPILImage()(Denormalize()(data[\"image\"].clone()))\n", + "msk = ToPILImage()(data[\"mask\"]).convert(\"RGB\")\n", + "\n", + "Image.fromarray(np.hstack((np.array(img), np.array(msk))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "#### Segmentation Task\n", + "### DataModule\n", "\n", - "It is also possible to configure the Folder dataset for the segmentation task, where the dataset object returns image and ground-truth mask." + "So far, we have shown the Torch Dataset implementation of Folder dataset. This is quite useful to get a sample. However, when we train models end-to-end fashion, we do need much more than this such as downloading the dataset, creating train/val/test/inference dataloaders. To handle all these, we have the PyTorch Lightning DataModule implementation, which is shown below" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ - "# Folder Segmentation Train Set\n", - "folder_dataset_segmentation_train = FolderDataset(\n", - " normal_dir=folder_dataset_root / \"good\",\n", - " abnormal_dir=folder_dataset_root / \"crack\",\n", - " split=\"train\",\n", - " transform=transform,\n", - " mask_dir=folder_dataset_root / \"mask\" / \"crack\",\n", + "folder_datamodule = Folder(\n", + " root=\"../../datasets/hazelnut_toy/\",\n", + " normal_dir=\"good\",\n", + " abnormal_dir=\"crack\",\n", " task=\"segmentation\",\n", + " mask_dir=\"../../datasets/hazelnut_toy/mask/crack\",\n", + " image_size=256,\n", ")\n", - "folder_dataset_segmentation_train.setup() # like the datamodule, the dataset needs to be set up before use\n", - "folder_dataset_segmentation_train.samples.head()" + "folder_datamodule.setup()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(dict_keys(['image']), torch.Size([28, 3, 256, 256]))" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Folder Segmentation Test Set\n", - "folder_dataset_segmentation_test = FolderDataset(\n", - " normal_dir=folder_dataset_root / \"good\",\n", - " abnormal_dir=folder_dataset_root / \"crack\",\n", - " split=\"test\",\n", - " transform=transform,\n", - " mask_dir=folder_dataset_root / \"mask\" / \"crack\",\n", - " task=\"segmentation\",\n", - ")\n", - "folder_dataset_segmentation_test.setup() # like the datamodule, the dataset needs to be set up before use\n", - "folder_dataset_segmentation_test.samples.head(10)" + "# Train images\n", + "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n", + "data.keys(), data[\"image\"].shape" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(dict_keys(['image', 'image_path', 'label', 'mask_path', 'mask']),\n", + " torch.Size([11, 3, 256, 256]),\n", + " torch.Size([11, 256, 256]))" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "data = folder_dataset_segmentation_test[3]\n", - "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)" + "# Test images\n", + "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n", + "data.keys(), data[\"image\"].shape, data[\"mask\"].shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's visualize the image and the mask..." + "As can be seen above, creating the dataloaders are pretty straghtforward, which could be directly used for training/testing/inference. We could visualize samples from the dataloaders as well." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "img = ToPILImage()(data[\"image\"].clone())\n", - "msk = ToPILImage()(data[\"mask\"]).convert(\"RGB\")\n", + "img = ToPILImage()(Denormalize()(data[\"image\"][0].clone()))\n", + "msk = ToPILImage()(data[\"mask\"][0]).convert(\"RGB\")\n", "\n", "Image.fromarray(np.hstack((np.array(img), np.array(msk))))" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`Folder` data module offers much more flexibility cater all different sorts of needs. Please refer to the documentation for more details." + ] } ], "metadata": { + "interpreter": { + "hash": "f26beec5b578f06009232863ae217b956681fd13da2e828fa5a0ecf8cf2ccd29" + }, "kernelspec": { - "display_name": "anomalib", + "display_name": "Python 3.8.12 ('anomalib')", "language": "python", "name": "python3" }, @@ -361,14 +796,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.13 (default, Nov 6 2022, 23:15:27) \n[GCC 9.3.0]" + "version": "3.8.12" }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "ae223df28f60859a2f400fae8b3a1034248e0a469f5599fd9a89c32908ed7a84" - } - } + "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2