From c4d2666bf57ff5d74463f19f2f667fc54d325d75 Mon Sep 17 00:00:00 2001 From: a r Date: Fri, 26 Aug 2022 12:02:45 +0200 Subject: [PATCH 01/21] add heat map to classification --- anomalib/post_processing/visualizer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/anomalib/post_processing/visualizer.py b/anomalib/post_processing/visualizer.py index 409a52b4a2..2eae45413d 100644 --- a/anomalib/post_processing/visualizer.py +++ b/anomalib/post_processing/visualizer.py @@ -123,6 +123,7 @@ def _visualize_full(self, image_result: ImageResult) -> np.ndarray: visualization.add_image(image=image_result.segmentations, title="Segmentation Result") elif self.task == "classification": visualization.add_image(image_result.image, title="Image") + 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: From e86f9c2527a851fe4eb93b6559807da9f68de37b Mon Sep 17 00:00:00 2001 From: Alexander Riedel <54716527+alexriedel1@users.noreply.github.com> Date: Tue, 8 Nov 2022 16:16:33 +0100 Subject: [PATCH 02/21] fix assertion if no masks are provided --- anomalib/data/folder.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index b928c785bb..e48cb83682 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -139,11 +139,11 @@ def make_dataset( if row.label_index == 1: samples.loc[index, "mask_path"] = str(mask_dir / row.image_path.name) - # 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}" + # 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}" # Ensure the pathlib objects are converted to str. # This is because torch dataloader doesn't like pathlib. From 35e50cedd73fa4d63215a2c67331883f6c62a429 Mon Sep 17 00:00:00 2001 From: a r Date: Thu, 2 Feb 2023 13:14:55 +0100 Subject: [PATCH 03/21] first commit mvtec3d --- anomalib/data/mvtec_3d.py | 265 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 anomalib/data/mvtec_3d.py diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py new file mode 100644 index 0000000000..713190eafe --- /dev/null +++ b/anomalib/data/mvtec_3d.py @@ -0,0 +1,265 @@ +"""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, AnomalibDataset +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="eefca59f2cede9c3fc5b6befbfec275e", +) + + +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 rgb_image_path gt_mask_path depth_image_path label_index + 0 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/105.png MVTec3D/bagel/ground_truth/good/gt/105.png MVTec3D/bagel/ground_truth/good/xyz/105.tiff 0 + 1 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/017.png MVTec3D/bagel/ground_truth/good/gt/017.png MVTec3D/bagel/ground_truth/good/xyz/017.tiff 0 + 2 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/137.png MVTec3D/bagel/ground_truth/good/gt/137.png MVTec3D/bagel/ground_truth/good/xyz/137.tiff 0 + 3 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/152.png MVTec3D/bagel/ground_truth/good/gt/152.png MVTec3D/bagel/ground_truth/good/xyz/152.tiff 0 + 4 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/109.png MVTec3D/bagel/ground_truth/good/gt/109.png 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[-3:] 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", "rgb_image_path", "gt_mask_path", "depth_image_path"]) + + # Modify image_path column by converting to absolute path + samples["rgb_image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.rgb_image_path + + # 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 == "ground_truth"].sort_values(by="rgb_image_path", ignore_index=True) + samples = samples[samples.split != "ground_truth"].sort_values(by="rgb_image_path", ignore_index=True) + + # assign mask paths to anomalous test images + samples["mask_path"] = "" + samples.loc[(samples.split == "test") & (samples.label_index == 1), "mask_path"] = mask_samples.rgb_image_path.values + + # 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.rgb_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')." + + if split: + samples = samples[samples.split == split].reset_index(drop=True) + + return samples + + +class MVTec3DDataset(AnomalibDataset): + """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. 'bottle' + """ + + 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) + + +if __name__ == "__main__": + print("TEST") + From b8ec0bab3b1cb3c086fabbb4958cc32fc9badca3 Mon Sep 17 00:00:00 2001 From: a r Date: Thu, 2 Feb 2023 14:12:38 +0100 Subject: [PATCH 04/21] main test --- anomalib/data/base/datamodule.py | 2 +- anomalib/data/mvtec_3d.py | 3 +++ 2 files changed, 4 insertions(+), 1 deletion(-) 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/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 713190eafe..1573aa1e83 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -262,4 +262,7 @@ def prepare_data(self) -> None: if __name__ == "__main__": print("TEST") + mvtec_3d = MVTec3D(root="./MVTec3D", category="bagel", image_size=256) + + mvtec_3d.setup() From 95945cc67e96f127ee3baeb9aa1052b835fe1bda Mon Sep 17 00:00:00 2001 From: a r Date: Thu, 2 Feb 2023 14:56:20 +0100 Subject: [PATCH 05/21] construct filename df --- anomalib/data/mvtec_3d.py | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 1573aa1e83..86a4871457 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -50,7 +50,7 @@ name="mvtec_3d", url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832" "/mvtec_3d_anomaly_detection.tar.xz", - hash="eefca59f2cede9c3fc5b6befbfec275e", + hash="", ) @@ -106,15 +106,15 @@ def make_mvtec_3d_dataset( extensions = IMG_EXTENSIONS root = Path(root) - samples_list = [(str(root),) + f.parts[-3:] for f in root.glob(r"**/*") if f.suffix in extensions] + 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", "rgb_image_path", "gt_mask_path", "depth_image_path"]) - + samples = DataFrame(samples_list, columns=["path", "split", "label", "type", "file_name"]) + # Modify image_path column by converting to absolute path - samples["rgb_image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.rgb_image_path - + samples["rgb_image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.file_name + print(samples_list) # 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 @@ -263,6 +263,5 @@ def prepare_data(self) -> None: if __name__ == "__main__": print("TEST") mvtec_3d = MVTec3D(root="./MVTec3D", category="bagel", image_size=256) - mvtec_3d.setup() From 9ada94ed7036a382db2660a7123d63e08ebbb816 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Tue, 7 Feb 2023 15:23:29 +0100 Subject: [PATCH 06/21] mvtec 3d implemented --- anomalib/data/base/__init__.py | 3 +- anomalib/data/base/depth.py | 76 ++++++++++++++++++++++++++++++++ anomalib/data/mvtec_3d.py | 64 ++++++++++++++++++++------- anomalib/data/utils/__init__.py | 2 + anomalib/data/utils/image.py | 18 ++++++++ anomalib/data/utils/transform.py | 2 +- 6 files changed, 148 insertions(+), 17 deletions(-) create mode 100644 anomalib/data/base/depth.py diff --git a/anomalib/data/base/__init__.py b/anomalib/data/base/__init__.py index 936388b228..206261c0c2 100644 --- a/anomalib/data/base/__init__.py +++ b/anomalib/data/base/__init__.py @@ -7,5 +7,6 @@ from .datamodule import AnomalibDataModule from .dataset import AnomalibDataset from .video import AnomalibVideoDataModule, AnomalibVideoDataset +from .depth import AnomalibDepthDataset -__all__ = ["AnomalibDataset", "AnomalibDataModule", "AnomalibVideoDataset", "AnomalibVideoDataModule"] +__all__ = ["AnomalibDataset", "AnomalibDataModule", "AnomalibVideoDataset", "AnomalibVideoDataModule", "AnomalibDepthDataset"] diff --git a/anomalib/data/base/depth.py b/anomalib/data/base/depth.py new file mode 100644 index 0000000000..7c0a45f33f --- /dev/null +++ b/anomalib/data/base/depth.py @@ -0,0 +1,76 @@ +"""Base Depth Dataset.""" + +from __future__ import annotations + +from abc import ABC +from typing import Callable + +import albumentations as A +import cv2 +import numpy as np +import pandas as pd +import torch +from pandas import DataFrame +from torch import Tensor + +from anomalib.data.base.datamodule import AnomalibDataModule +from anomalib.data.base.dataset import AnomalibDataset +from anomalib.data.task_type import TaskType +from anomalib.data.utils import masks_to_boxes, read_image, read_depth_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 \ No newline at end of file diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 86a4871457..3c3944c120 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -29,7 +29,7 @@ import albumentations as A from pandas import DataFrame -from anomalib.data.base import AnomalibDataModule, AnomalibDataset +from anomalib.data.base import AnomalibDataModule, AnomalibDataset, AnomalibDepthDataset from anomalib.data.task_type import TaskType from anomalib.data.utils import ( DownloadInfo, @@ -92,7 +92,7 @@ def make_mvtec_3d_dataset( >>> samples = make_mvtec_3d_dataset(path, split='train', split_ratio=0.1, seed=0) >>> samples.head() - path split label rgb_image_path gt_mask_path depth_image_path label_index + path split label image_path mask_path depth_path label_index 0 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/105.png MVTec3D/bagel/ground_truth/good/gt/105.png MVTec3D/bagel/ground_truth/good/xyz/105.tiff 0 1 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/017.png MVTec3D/bagel/ground_truth/good/gt/017.png MVTec3D/bagel/ground_truth/good/xyz/017.tiff 0 2 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/137.png MVTec3D/bagel/ground_truth/good/gt/137.png MVTec3D/bagel/ground_truth/good/xyz/137.tiff 0 @@ -113,25 +113,26 @@ def make_mvtec_3d_dataset( samples = DataFrame(samples_list, columns=["path", "split", "label", "type", "file_name"]) # Modify image_path column by converting to absolute path - samples["rgb_image_path"] = samples.path + "/" + samples.split + "/" + samples.label + "/" + samples.file_name - print(samples_list) + 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 == "ground_truth"].sort_values(by="rgb_image_path", ignore_index=True) - samples = samples[samples.split != "ground_truth"].sort_values(by="rgb_image_path", ignore_index=True) + 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 anomalous test images - samples["mask_path"] = "" - samples.loc[(samples.split == "test") & (samples.label_index == 1), "mask_path"] = mask_samples.rgb_image_path.values + # 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) # 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.rgb_image_path).stem in Path(x.mask_path).stem, axis=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', \ @@ -139,11 +140,11 @@ def make_mvtec_3d_dataset( if split: samples = samples[samples.split == split].reset_index(drop=True) - + return samples -class MVTec3DDataset(AnomalibDataset): +class MVTec3DDataset(AnomalibDepthDataset): """MVTec 3D dataset class. Args: @@ -261,7 +262,40 @@ def prepare_data(self) -> None: if __name__ == "__main__": - print("TEST") - mvtec_3d = MVTec3D(root="./MVTec3D", category="bagel", image_size=256) + import pandas as pd + pd.set_option('display.max_rows', 500) + pd.set_option('display.max_columns', 20) + pd.set_option('display.width', 1000) + from albumentations.pytorch import ToTensorV2 + + augment = A.to_dict(A.Compose( + [ + A.Resize(height=256, width=256, always_apply=True), + #A.HorizontalFlip(p=0.5), + A.VerticalFlip(p=0.5), + A.ElasticTransform(alpha =1.3, sigma=17, alpha_affine =12, p=0.2), + A.ShiftScaleRotate(p=0.9), + #A.ToGray(always_apply=True), + A.RandomBrightnessContrast(p=0.3), + A.Blur(blur_limit=[5,5], always_apply=True), + #A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), + ToTensorV2(), + ], additional_targets={'image': 'image', 'depth_image': 'image'}), ) + mvtec_3d = MVTec3D(root="./datasets/mvtec3d", category="bagel", image_size=256, transform_config_train=A.from_dict(augment), transform_config_eval=A.from_dict(augment)) mvtec_3d.setup() + #print(mvtec_3d.train_data.samples) + data = mvtec_3d.test_data[3] + print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') + print(data["depth_image"].shape) + + import matplotlib.pyplot as plt + + + + f, axarr = plt.subplots(3,1) + axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) + axarr[1].imshow(data["image"].permute(1, 2, 0)) + axarr[2].imshow(data["mask"]) + + plt.show() diff --git a/anomalib/data/utils/__init__.py b/anomalib/data/utils/__init__.py index 2fa61f72c7..f54d1c35d3 100644 --- a/anomalib/data/utils/__init__.py +++ b/anomalib/data/utils/__init__.py @@ -12,6 +12,7 @@ get_image_filenames, get_image_height_and_width, read_image, + read_depth_image ) from .split import ( Split, @@ -29,6 +30,7 @@ "get_image_height_and_width", "random_2d_perlin", "read_image", + "read_depth_image", "random_split", "split_by_label", "concatenate_datasets", diff --git a/anomalib/data/utils/image.py b/anomalib/data/utils/image.py index cb3ee898ca..c72d3bab61 100644 --- a/anomalib/data/utils/image.py +++ b/anomalib/data/utils/image.py @@ -15,6 +15,8 @@ from torch import Tensor from torchvision.datasets.folder import IMG_EXTENSIONS +import tifffile as tiff + def get_image_filenames(path: str | Path) -> list[Path]: """Get image filenames. @@ -205,6 +207,22 @@ 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/transform.py b/anomalib/data/utils/transform.py index cbfa3b372b..70fa0e2f4c 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 From 8f969d0377712156116ff4865f2c495b2ba10527 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Tue, 7 Feb 2023 15:52:45 +0100 Subject: [PATCH 07/21] folder dataset 3d ready --- anomalib/data/folder.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index d0a7892abc..4b126a1030 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -99,6 +99,9 @@ def make_folder_dataset( 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: @@ -136,6 +139,15 @@ def make_folder_dataset( 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": abnormal_depth_dir}} for dir_type, path in dirs.items(): filename, label = _prepare_files_labels(path, dir_type, extensions) From e8fb5f4d9e91250c9d0aff4158a8bdc198579f67 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Fri, 10 Feb 2023 17:31:12 +0100 Subject: [PATCH 08/21] folder dataset 3d --- .pre-commit-config.yaml | 16 +-- anomalib/data/base/__init__.py | 10 +- anomalib/data/base/depth.py | 14 +-- anomalib/data/folder.py | 153 +++++++++++++++++++++++++--- anomalib/data/mvtec_3d.py | 123 ++++++++++++++-------- anomalib/data/utils/__init__.py | 2 +- anomalib/data/utils/image.py | 5 +- anomalib/data/utils/transform.py | 2 +- docs/source/how_to_guides/notebooks | 2 +- 9 files changed, 248 insertions(+), 79 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index aacdd3ab9b..d5ab119d32 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -77,15 +77,15 @@ repos: - id: nbqa-flake8 - id: nbqa-pylint - - repo: https://github.com/pre-commit/mirrors-prettier - rev: v2.7.1 - hooks: - - id: prettier + #- repo: https://github.com/pre-commit/mirrors-prettier + # rev: v2.7.1 + # hooks: + # - id: prettier - - repo: https://github.com/igorshubovych/markdownlint-cli - rev: v0.32.2 - hooks: - - id: markdownlint + #- repo: https://github.com/igorshubovych/markdownlint-cli + # rev: v0.32.2 + # hooks: + # - id: markdownlint - repo: https://github.com/AleksaC/hadolint-py rev: v2.10.0 diff --git a/anomalib/data/base/__init__.py b/anomalib/data/base/__init__.py index 206261c0c2..00d67a7ea3 100644 --- a/anomalib/data/base/__init__.py +++ b/anomalib/data/base/__init__.py @@ -6,7 +6,13 @@ from .datamodule import AnomalibDataModule from .dataset import AnomalibDataset -from .video import AnomalibVideoDataModule, AnomalibVideoDataset from .depth import AnomalibDepthDataset +from .video import AnomalibVideoDataModule, AnomalibVideoDataset -__all__ = ["AnomalibDataset", "AnomalibDataModule", "AnomalibVideoDataset", "AnomalibVideoDataModule", "AnomalibDepthDataset"] +__all__ = [ + "AnomalibDataset", + "AnomalibDataModule", + "AnomalibVideoDataset", + "AnomalibVideoDataModule", + "AnomalibDepthDataset", +] diff --git a/anomalib/data/base/depth.py b/anomalib/data/base/depth.py index 7c0a45f33f..f495342926 100644 --- a/anomalib/data/base/depth.py +++ b/anomalib/data/base/depth.py @@ -3,21 +3,15 @@ from __future__ import annotations from abc import ABC -from typing import Callable import albumentations as A import cv2 import numpy as np -import pandas as pd -import torch -from pandas import DataFrame from torch import Tensor -from anomalib.data.base.datamodule import AnomalibDataModule from anomalib.data.base.dataset import AnomalibDataset from anomalib.data.task_type import TaskType -from anomalib.data.utils import masks_to_boxes, read_image, read_depth_image - +from anomalib.data.utils import masks_to_boxes, read_depth_image, read_image class AnomalibDepthDataset(AnomalibDataset, ABC): @@ -28,13 +22,11 @@ class AnomalibDepthDataset(AnomalibDataset, ABC): transform (A.Compose): Albumentations Compose object describing the transforms that are applied to the inputs. """ - def __init__( - self, task: TaskType, transform: A.Compose) -> None: + 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.""" @@ -73,4 +65,4 @@ def __getitem__(self, index: int) -> dict[str, str | Tensor]: else: raise ValueError(f"Unknown task type: {self.task}") - return item \ No newline at end of file + return item diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index 4b126a1030..28ef741ba0 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -14,7 +14,7 @@ from pandas import DataFrame from torchvision.datasets.folder import IMG_EXTENSIONS -from anomalib.data.base import AnomalibDataModule, AnomalibDataset +from anomalib.data.base import AnomalibDataModule, AnomalibDataset, AnomalibDepthDataset from anomalib.data.task_type import TaskType from anomalib.data.utils import ( InputNormalizationMethod, @@ -116,6 +116,13 @@ def make_folder_dataset( 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 @@ -128,6 +135,10 @@ def make_folder_dataset( 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 = [] @@ -139,33 +150,39 @@ def make_folder_dataset( 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": abnormal_depth_dir}} + dirs = {**dirs, **{"normal_test_depth": normal_test_depth_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 = 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.loc[(samples.label == "normal") | + (samples.label == "normal_test") | + (samples.label == "normal_depth") | + (samples.label == "normal_test_depth"), "label_index"] = 0 + samples.loc[(samples.label == "abnormal") | + (samples.label == "abnormal_depth"), "label_index"] = 1 samples.label_index = samples.label_index.astype(int) + # # 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: + if row.label_index == 1 and not "depth" in row.label: rel_image_path = row.image_path.relative_to(abnormal_dir) samples.loc[index, "mask_path"] = str(mask_dir / rel_image_path) @@ -175,6 +192,30 @@ def make_folder_dataset( lambda x: Path(x).exists() if x != "" else True ).all(), f"missing mask files, mask_dir={mask_dir}" + + 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 + + samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] + + # make sure all 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 x != "" else True + ).all(), f"missing depth image files" + + # Ensure the pathlib objects are converted to str. # This is because torch dataloader doesn't like pathlib. samples = samples.astype({"image_path": "str"}) @@ -193,7 +234,7 @@ def make_folder_dataset( return samples -class FolderDataset(AnomalibDataset): +class FolderDataset(AnomalibDepthDataset): """Folder dataset. Args: @@ -208,7 +249,13 @@ class FolderDataset(AnomalibDataset): 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. @@ -227,9 +274,13 @@ def __init__( 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 @@ -238,6 +289,9 @@ def __init__( 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: @@ -248,6 +302,9 @@ def _setup(self) -> None: 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, ) @@ -266,6 +323,13 @@ class Folder(AnomalibDataModule): 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. @@ -301,6 +365,9 @@ def __init__( 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, normal_split_ratio: float = 0.2, extensions: tuple[str] | None = None, image_size: int | tuple[int, int] | None = None, @@ -343,7 +410,7 @@ def __init__( center_crop=center_crop, normalization=InputNormalizationMethod(normalization), ) - + self.train_data = FolderDataset( task=task, transform=transform_train, @@ -353,6 +420,9 @@ def __init__( 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, ) @@ -364,6 +434,65 @@ def __init__( 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, ) + +if __name__ == "__main__": + import pandas as pd + + pd.set_option('display.max_columns', None) + pd.set_option('display.max_rows', None) + pd.set_option("display.width", 2000) + pd.set_option('display.max_colwidth', None) + from albumentations.pytorch import ToTensorV2 + + augment = A.to_dict( + A.Compose( + [ + A.Resize(height=256, width=256, always_apply=True), + # A.HorizontalFlip(p=0.5), + A.VerticalFlip(p=0.5), + A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), + A.ShiftScaleRotate(p=0.9), + # A.ToGray(always_apply=True), + A.RandomBrightnessContrast(p=0.3), + A.Blur(blur_limit=[5, 5], always_apply=True), + # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), + ToTensorV2(), + ], + additional_targets={"image": "image", "depth_image": "image"}, + ), + ) + folder_dataset_root = Path("C:/Users/REH/anomalib/datasets/mvtec3d") + + mvtec_3d = Folder( + root=folder_dataset_root , + normal_dir=folder_dataset_root / "bagel/train/good/rgb", + abnormal_dir= folder_dataset_root / "bagel/test/combined/rgb", + normal_test_dir=folder_dataset_root / "bagel/test/good/rgb", + mask_dir=folder_dataset_root / "bagel/test/combined/gt", + normal_depth_dir=folder_dataset_root / "bagel/train/good/xyz", + abnormal_depth_dir=folder_dataset_root / "bagel/test/combined/xyz",# + normal_test_depth_dir=folder_dataset_root /"bagel/test/good/xyz", + image_size=256, + transform_config_train=A.from_dict(augment), + transform_config_eval=A.from_dict(augment), + ) + mvtec_3d.setup() + # print(mvtec_3d.train_data.samples) + data = mvtec_3d.test_data[3] + print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') + print(data["depth_image"].shape) + + import matplotlib.pyplot as plt + + f, axarr = plt.subplots(3, 1) + axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) + axarr[1].imshow(data["image"].permute(1, 2, 0)) + axarr[2].imshow(data["mask"]) + + plt.show() \ No newline at end of file diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 3c3944c120..5adb45e609 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -10,10 +10,10 @@ 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: + - 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, + 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. """ @@ -29,7 +29,7 @@ import albumentations as A from pandas import DataFrame -from anomalib.data.base import AnomalibDataModule, AnomalibDataset, AnomalibDepthDataset +from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset from anomalib.data.task_type import TaskType from anomalib.data.utils import ( DownloadInfo, @@ -92,12 +92,18 @@ def make_mvtec_3d_dataset( >>> samples = make_mvtec_3d_dataset(path, split='train', split_ratio=0.1, seed=0) >>> samples.head() - path split label image_path mask_path depth_path label_index - 0 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/105.png MVTec3D/bagel/ground_truth/good/gt/105.png MVTec3D/bagel/ground_truth/good/xyz/105.tiff 0 - 1 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/017.png MVTec3D/bagel/ground_truth/good/gt/017.png MVTec3D/bagel/ground_truth/good/xyz/017.tiff 0 - 2 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/137.png MVTec3D/bagel/ground_truth/good/gt/137.png MVTec3D/bagel/ground_truth/good/xyz/137.tiff 0 - 3 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/152.png MVTec3D/bagel/ground_truth/good/gt/152.png MVTec3D/bagel/ground_truth/good/xyz/152.tiff 0 - 4 MVTec3D/bagel train good MVTec3D/bagel/train/good/rgb/109.png MVTec3D/bagel/ground_truth/good/gt/109.png MVTec3D/bagel/ground_truth/good/xyz/109.tiff 0 + 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. @@ -111,23 +117,39 @@ def make_mvtec_3d_dataset( 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" + 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) + 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.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) # assert that the right mask files are associated with the right test images assert ( @@ -137,10 +159,19 @@ def make_mvtec_3d_dataset( ), "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 @@ -152,7 +183,7 @@ class MVTec3DDataset(AnomalibDepthDataset): 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. 'bottle' + category (str): Sub-category of the dataset, e.g. 'bagel' """ def __init__( @@ -263,39 +294,49 @@ def prepare_data(self) -> None: if __name__ == "__main__": import pandas as pd - pd.set_option('display.max_rows', 500) - pd.set_option('display.max_columns', 20) - pd.set_option('display.width', 1000) + + pd.set_option("display.max_rows", 500) + pd.set_option("display.max_columns", 20) + pd.set_option("display.width", 1000) from albumentations.pytorch import ToTensorV2 - augment = A.to_dict(A.Compose( - [ - A.Resize(height=256, width=256, always_apply=True), - #A.HorizontalFlip(p=0.5), - A.VerticalFlip(p=0.5), - A.ElasticTransform(alpha =1.3, sigma=17, alpha_affine =12, p=0.2), - A.ShiftScaleRotate(p=0.9), - #A.ToGray(always_apply=True), - A.RandomBrightnessContrast(p=0.3), - A.Blur(blur_limit=[5,5], always_apply=True), - #A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), - ToTensorV2(), - ], additional_targets={'image': 'image', 'depth_image': 'image'}), ) - mvtec_3d = MVTec3D(root="./datasets/mvtec3d", category="bagel", image_size=256, transform_config_train=A.from_dict(augment), transform_config_eval=A.from_dict(augment)) + augment = A.to_dict( + A.Compose( + [ + A.Resize(height=256, width=256, always_apply=True), + # A.HorizontalFlip(p=0.5), + A.VerticalFlip(p=0.5), + A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), + A.ShiftScaleRotate(p=0.9), + # A.ToGray(always_apply=True), + A.RandomBrightnessContrast(p=0.3), + A.Blur(blur_limit=[5, 5], always_apply=True), + # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), + ToTensorV2(), + ], + additional_targets={"image": "image", "depth_image": "image"}, + ), + ) + mvtec_3d = MVTec3D( + root="./datasets/mvtec3d", + category="bagel", + image_size=256, + transform_config_train=A.from_dict(augment), + transform_config_eval=A.from_dict(augment), + ) mvtec_3d.setup() - #print(mvtec_3d.train_data.samples) + # print(mvtec_3d.train_data.samples) data = mvtec_3d.test_data[3] + print(len(mvtec_3d.train_data)) + print(len(mvtec_3d.test_data)) print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') print(data["depth_image"].shape) import matplotlib.pyplot as plt - - - f, axarr = plt.subplots(3,1) + f, axarr = plt.subplots(3, 1) axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) axarr[1].imshow(data["image"].permute(1, 2, 0)) axarr[2].imshow(data["mask"]) plt.show() - diff --git a/anomalib/data/utils/__init__.py b/anomalib/data/utils/__init__.py index f54d1c35d3..bfbca7c516 100644 --- a/anomalib/data/utils/__init__.py +++ b/anomalib/data/utils/__init__.py @@ -11,8 +11,8 @@ generate_output_image_filename, get_image_filenames, get_image_height_and_width, + read_depth_image, read_image, - read_depth_image ) from .split import ( Split, diff --git a/anomalib/data/utils/image.py b/anomalib/data/utils/image.py index 07fed320d9..49aa043b86 100644 --- a/anomalib/data/utils/image.py +++ b/anomalib/data/utils/image.py @@ -11,12 +11,11 @@ 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 -import tifffile as tiff - def get_image_filenames(path: str | Path) -> list[Path]: """Get image filenames. @@ -207,6 +206,7 @@ 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. @@ -224,6 +224,7 @@ def read_depth_image(path: str | Path) -> np.ndarray: return image + def pad_nextpow2(batch: Tensor) -> Tensor: """Compute required padding from input size and return padded images. diff --git a/anomalib/data/utils/transform.py b/anomalib/data/utils/transform.py index 70fa0e2f4c..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, additional_targets={'image': 'image', 'depth_image': 'image'}) + transforms = A.Compose(transforms_list, additional_targets={"image": "image", "depth_image": "image"}) return transforms 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 From 81bcd063b0863713051c8fb54ce67c245009bcd8 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sat, 11 Feb 2023 10:41:59 +0100 Subject: [PATCH 09/21] folder 3d separate --- anomalib/data/base/dataset.py | 3 +- anomalib/data/folder.py | 65 +-- anomalib/data/folder_3d.py | 501 +++++++++++++++++++++ anomalib/data/mvtec_3d.py | 52 +-- notebooks/100_datamodules/103_folder.ipynb | 123 ++++- 5 files changed, 645 insertions(+), 99 deletions(-) create mode 100644 anomalib/data/folder_3d.py diff --git a/anomalib/data/base/dataset.py b/anomalib/data/base/dataset.py index b0e3f70da9..9b49b15446 100644 --- a/anomalib/data/base/dataset.py +++ b/anomalib/data/base/dataset.py @@ -119,13 +119,14 @@ def __getitem__(self, index: int) -> dict[str, str | Tensor]: image = read_image(image_path) item = dict(image_path=image_path, label=label_index) - + print(mask_path, label_index) if self.task == TaskType.CLASSIFICATION: transformed = self.transform(image=image) item["image"] = transformed["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: diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index 28ef741ba0..98c72c0a8d 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -159,6 +159,9 @@ def make_folder_dataset( 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) @@ -167,41 +170,23 @@ def make_folder_dataset( samples = DataFrame({"image_path": filenames, "label": labels, "mask_path": ""}) 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") | - (samples.label == "normal_depth") | - (samples.label == "normal_test_depth"), "label_index"] = 0 - samples.loc[(samples.label == "abnormal") | - (samples.label == "abnormal_depth"), "label_index"] = 1 - samples.label_index = samples.label_index.astype(int) - - # - # 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 and not "depth" in row.label: - 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}" + # 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 - - samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] - + + #samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] + + #samples = samples[pd.isnull(samples['label'])] # make sure all every rgb image has a corresponding depth image and that the file exists assert ( samples.loc[samples.label_index == 1] @@ -212,9 +197,23 @@ def make_folder_dataset( depth: '000.tiff')." assert samples.depth_path.apply( - lambda x: Path(x).exists() if x != "" else True + lambda x: Path(x).exists() if not pd.isna(x) else True ).all(), f"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. @@ -234,7 +233,7 @@ def make_folder_dataset( return samples -class FolderDataset(AnomalibDepthDataset): +class FolderDataset(AnomalibDataset): #AnomalibDepthDataset """Folder dataset. Args: @@ -484,7 +483,11 @@ def __init__( ) mvtec_3d.setup() # print(mvtec_3d.train_data.samples) - data = mvtec_3d.test_data[3] + i, data = next(enumerate(mvtec_3d.train_dataloader())) + #data = mvtec_3d.test_data[3] + print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') + print(data["depth_image"].shape) + i, data = next(enumerate(mvtec_3d.test_dataloader())) print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') print(data["depth_image"].shape) diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py new file mode 100644 index 0000000000..6373adbfef --- /dev/null +++ b/anomalib/data/folder_3d.py @@ -0,0 +1,501 @@ +"""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 +from torchvision.datasets.folder import IMG_EXTENSIONS + +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, +) + + +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 + + +def make_folder_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, "mask_path": ""}) + 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 + + #samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] + + #samples = samples[pd.isnull(samples['label'])] + # make sure all 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 pd.isna(x) else True + ).all(), f"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_folder_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, + normal_split_ratio: float = 0.2, + 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, + ) + + self.normal_split_ratio = normal_split_ratio + + 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, + ) + +if __name__ == "__main__": + import pandas as pd + + pd.set_option('display.max_columns', None) + pd.set_option('display.max_rows', None) + pd.set_option("display.width", 2000) + pd.set_option('display.max_colwidth', None) + from albumentations.pytorch import ToTensorV2 + + augment = A.to_dict( + A.Compose( + [ + A.Resize(height=256, width=256, always_apply=True), + # A.HorizontalFlip(p=0.5), + A.VerticalFlip(p=0.5), + A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), + A.ShiftScaleRotate(p=0.9), + # A.ToGray(always_apply=True), + A.RandomBrightnessContrast(p=0.3), + A.Blur(blur_limit=[5, 5], always_apply=True), + # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), + ToTensorV2(), + ], + additional_targets={"image": "image", "depth_image": "image"}, + ), + ) + folder_dataset_root = Path("C:/Users/REH/anomalib/datasets/mvtec3d") + + mvtec_3d = Folder3D( + root=folder_dataset_root , + normal_dir=folder_dataset_root / "bagel/train/good/rgb", + abnormal_dir= folder_dataset_root / "bagel/test/combined/rgb", + normal_test_dir=folder_dataset_root / "bagel/test/good/rgb", + mask_dir=folder_dataset_root / "bagel/test/combined/gt", + normal_depth_dir=folder_dataset_root / "bagel/train/good/xyz", + abnormal_depth_dir=folder_dataset_root / "bagel/test/combined/xyz",# + normal_test_depth_dir=folder_dataset_root /"bagel/test/good/xyz", + image_size=256, + transform_config_train=A.from_dict(augment), + transform_config_eval=A.from_dict(augment), + ) + mvtec_3d.setup() + # print(mvtec_3d.train_data.samples) + i, data = next(enumerate(mvtec_3d.train_dataloader())) + #data = mvtec_3d.test_data[3] + print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') + print(data["depth_image"].shape) + i, data = next(enumerate(mvtec_3d.test_dataloader())) + print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') + print(data["depth_image"].shape) + + import matplotlib.pyplot as plt + + f, axarr = plt.subplots(3, 1) + axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) + axarr[1].imshow(data["image"].permute(1, 2, 0)) + axarr[2].imshow(data["mask"]) + + plt.show() \ No newline at end of file diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 5adb45e609..932377abce 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -289,54 +289,4 @@ def prepare_data(self) -> None: if (self.root / self.category).is_dir(): logger.info("Found the dataset.") else: - download_and_extract(self.root, DOWNLOAD_INFO) - - -if __name__ == "__main__": - import pandas as pd - - pd.set_option("display.max_rows", 500) - pd.set_option("display.max_columns", 20) - pd.set_option("display.width", 1000) - from albumentations.pytorch import ToTensorV2 - - augment = A.to_dict( - A.Compose( - [ - A.Resize(height=256, width=256, always_apply=True), - # A.HorizontalFlip(p=0.5), - A.VerticalFlip(p=0.5), - A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), - A.ShiftScaleRotate(p=0.9), - # A.ToGray(always_apply=True), - A.RandomBrightnessContrast(p=0.3), - A.Blur(blur_limit=[5, 5], always_apply=True), - # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), - ToTensorV2(), - ], - additional_targets={"image": "image", "depth_image": "image"}, - ), - ) - mvtec_3d = MVTec3D( - root="./datasets/mvtec3d", - category="bagel", - image_size=256, - transform_config_train=A.from_dict(augment), - transform_config_eval=A.from_dict(augment), - ) - mvtec_3d.setup() - # print(mvtec_3d.train_data.samples) - data = mvtec_3d.test_data[3] - print(len(mvtec_3d.train_data)) - print(len(mvtec_3d.test_data)) - print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') - print(data["depth_image"].shape) - - import matplotlib.pyplot as plt - - f, axarr = plt.subplots(3, 1) - axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) - axarr[1].imshow(data["image"].permute(1, 2, 0)) - axarr[2].imshow(data["mask"]) - - plt.show() + download_and_extract(self.root, DOWNLOAD_INFO) \ No newline at end of file diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb index 977384ffe2..984bc2b3f4 100644 --- a/notebooks/100_datamodules/103_folder.ipynb +++ b/notebooks/100_datamodules/103_folder.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -34,7 +34,7 @@ " root_directory = current_directory / \"anomalib\"\n", "\n", "os.chdir(root_directory)\n", - "folder_dataset_root = root_directory / \"datasets\" / \"hazelnut_toy\"" + "folder_dataset_root = root_directory / \"datasets\" / \"MVTec\" /\"hazelnut\"" ] }, { @@ -54,7 +54,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -82,16 +82,79 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " image_path label mask_path label_index split\n", + "0 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\001.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\001_mask.png 1 test\n", + "1 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\006.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\006_mask.png 1 test\n", + "2 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\007.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\007_mask.png 1 test\n", + "3 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\009.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\009_mask.png 1 test\n", + "4 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\010.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\010_mask.png 1 test\n", + "5 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\011.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\011_mask.png 1 test\n", + "6 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\013.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\013_mask.png 1 test\n", + "7 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\014.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\014_mask.png 1 test\n", + "8 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\016.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\016_mask.png 1 test\n", + "9 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\000.png normal 0 train\n", + "10 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\022.png normal 0 train\n", + "11 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\038.png normal 0 train\n", + "12 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\040.png normal 0 train\n", + "13 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\044.png normal 0 train\n", + "14 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\045.png normal 0 train\n", + "15 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\059.png normal 0 train\n", + "16 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\066.png normal 0 train\n", + "17 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\069.png normal 0 train\n", + "18 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\080.png normal 0 train\n", + "19 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\082.png normal 0 train\n", + "20 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\100.png normal 0 train\n", + "21 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\125.png normal 0 train\n", + "22 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\127.png normal 0 train\n", + "23 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\138.png normal 0 train\n", + "24 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\146.png normal 0 train\n", + "25 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\147.png normal 0 train\n", + "26 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\156.png normal 0 train\n", + "27 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\160.png normal 0 train\n", + "28 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\174.png normal 0 train\n", + "29 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\180.png normal 0 train\n", + "30 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\185.png normal 0 train\n", + "31 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\195.png normal 0 train\n", + "32 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\212.png normal 0 train\n", + "33 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\224.png normal 0 train\n", + "34 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\243.png normal 0 train\n", + "35 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\246.png normal 0 train\n", + "36 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\250.png normal 0 train\n", + "37 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\268.png normal 0 train\n", + "38 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\285.png normal 0 train\n", + "39 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\292.png normal 0 train\n", + "40 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\314.png normal 0 train\n", + "41 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\318.png normal 0 train\n", + "42 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\321.png normal 0 train\n", + "43 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\352.png normal 0 train\n", + "44 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\354.png normal 0 train\n", + "45 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\371.png normal 0 train\n", + "46 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\372.png normal 0 train\n", + "47 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\384.png normal 0 train\n" + ] + } + ], "source": [ + "import pandas as pd\n", + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.max_rows', None)\n", + "pd.set_option(\"display.width\", 2000)\n", + "pd.set_option('display.max_colwidth', None)\n", + "\n", + "\n", "folder_datamodule = Folder(\n", " root=folder_dataset_root,\n", - " normal_dir=\"good\",\n", - " abnormal_dir=\"crack\",\n", + " normal_dir=\"train/good\",\n", + " abnormal_dir=\"test/crack\",\n", " task=\"segmentation\",\n", - " mask_dir=folder_dataset_root / \"mask\" / \"crack\",\n", + " mask_dir=folder_dataset_root / \"ground_truth\" /\"crack\",\n", " image_size=256,\n", " normalization=InputNormalizationMethod.NONE, # don't apply normalization, as we want to visualize the images\n", ")\n", @@ -100,9 +163,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask']) torch.Size([32, 3, 256, 256])\n" + ] + } + ], "source": [ "# Train images\n", "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n", @@ -111,9 +182,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask']) torch.Size([32, 3, 256, 256]) torch.Size([32, 256, 256])\n" + ] + } + ], "source": [ "# Test images\n", "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n", @@ -129,9 +208,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "img = ToPILImage()(data[\"image\"][0].clone())\n", "msk = ToPILImage()(data[\"mask\"][0]).convert(\"RGB\")\n", @@ -361,12 +452,12 @@ "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" + "hash": "1fd01f0f7bed3bf30e7776b25350aa77bee0815d858f4fbea6a39e3e49268879" } } }, From b172760551e60b36045eb3588a4ddcf55f5ad8cd Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sat, 11 Feb 2023 10:42:34 +0100 Subject: [PATCH 10/21] original folder --- anomalib/data/folder.py | 797 +++++++++++++++++++++------------------- 1 file changed, 417 insertions(+), 380 deletions(-) diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index 98c72c0a8d..0f3b47adbd 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -6,30 +6,38 @@ # Copyright (C) 2022 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -from __future__ import annotations - +import logging +import warnings from pathlib import Path +from typing import Dict, Optional, Tuple, Union import albumentations as A -from pandas import DataFrame +import cv2 +import numpy as np +from pandas.core.frame import DataFrame +from pytorch_lightning.core.datamodule import LightningDataModule +from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY +from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS +from torch import Tensor +from torch.utils.data import DataLoader, Dataset from torchvision.datasets.folder import IMG_EXTENSIONS -from anomalib.data.base import AnomalibDataModule, AnomalibDataset, AnomalibDepthDataset -from anomalib.data.task_type import TaskType -from anomalib.data.utils import ( - InputNormalizationMethod, - Split, - TestSplitMode, - ValSplitMode, - get_transforms, +from anomalib.data.inference import InferenceDataset +from anomalib.data.utils import read_image +from anomalib.data.utils.split import ( + create_validation_set_from_test_set, + split_normal_images_in_train_set, ) +from anomalib.pre_processing import PreProcessor + +logger = logging.getLogger(__name__) -def _check_and_convert_path(path: str | Path) -> Path: +def _check_and_convert_path(path: Union[str, Path]) -> Path: """Check an input path, and convert to Pathlib object. Args: - path (str | Path): Input path. + path (Union[str, Path]): Input path. Returns: Path: Output path converted to pathlib object. @@ -40,14 +48,14 @@ def _check_and_convert_path(path: str | Path) -> Path: def _prepare_files_labels( - path: str | Path, path_type: str, extensions: tuple[str, ...] | None = None -) -> tuple[list, list]: + path: Union[str, Path], path_type: str, extensions: Optional[Tuple[str, ...]] = None +) -> Tuple[list, list]: """Return a list of filenames and list corresponding labels. Args: - path (str | Path): Path to the directory containing images. + path (Union[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 + extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the directory. Returns: @@ -61,7 +69,7 @@ def _prepare_files_labels( extensions = (extensions,) filenames = [f for f in path.glob(r"**/*") if f.suffix in extensions and not f.is_dir()] - if not filenames: + if len(filenames) == 0: raise RuntimeError(f"Found 0 {path_type} images in {path}") labels = [path_type] * len(filenames) @@ -69,151 +77,67 @@ def _prepare_files_labels( 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 - - -def make_folder_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: +def make_dataset( + normal_dir: Union[str, Path], + abnormal_dir: Union[str, Path], + normal_test_dir: Optional[Union[str, Path]] = None, + mask_dir: Optional[Union[str, Path]] = None, + split: Optional[str] = None, + split_ratio: float = 0.2, + seed: Optional[int] = None, + create_validation_set: bool = True, + extensions: Optional[Tuple[str, ...]] = None, +): """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_dir (Union[str, Path]): Path to the directory containing normal images. + abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images. + normal_test_dir (Optional[Union[str, Path]], 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 + mask_dir (Optional[Union[str, Path]], 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 + split (Optional[str], 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.2. + 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. + Those wanting to create a validation set could set this flag to ``True``. + extensions (Optional[Tuple[str, ...]], 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}} + dirs = {"normal": normal_dir, "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, "mask_path": ""}) - samples = samples.sort_values(by="image_path", ignore_index=True) + + samples = DataFrame({"image_path": filenames, "label": labels}) # 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") + samples.label_index = samples.label_index.astype(int) - # 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 - - #samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] - - #samples = samples[pd.isnull(samples['label'])] - # make sure all 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 pd.isna(x) else True - ).all(), f"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")] + mask_dir = _check_and_convert_path(mask_dir) + samples["mask_path"] = "" + for index, row in samples.iterrows(): + if row.label_index == 1: + samples.loc[index, "mask_path"] = str(mask_dir / row.image_path.name) # Ensure the pathlib objects are converted to str. # This is because torch dataloader doesn't like pathlib. @@ -225,277 +149,390 @@ def make_folder_dataset( samples.loc[(samples.label == "normal"), "split"] = "train" samples.loc[(samples.label == "abnormal") | (samples.label == "normal_test"), "split"] = "test" + if not normal_test_dir: + samples = split_normal_images_in_train_set( + samples=samples, split_ratio=split_ratio, seed=seed, normal_label="normal" + ) + + # If `create_validation_set` is set to True, the test set is split into half. + if create_validation_set: + samples = create_validation_set_from_test_set(samples, seed=seed, normal_label="normal") + # Get the data frame for the split. - if split: + if split is not None and split in ["train", "val", "test"]: samples = samples[samples.split == split] samples = samples.reset_index(drop=True) return samples -class FolderDataset(AnomalibDataset): #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`. - """ +class FolderDataset(Dataset): + """Folder Dataset.""" 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, + normal_dir: Union[Path, str], + abnormal_dir: Union[Path, str], + split: str, + pre_process: PreProcessor, + normal_test_dir: Optional[Union[Path, str]] = None, + split_ratio: float = 0.2, + mask_dir: Optional[Union[Path, str]] = None, + extensions: Optional[Tuple[str, ...]] = None, + task: Optional[str] = None, + seed: Optional[int] = None, + create_validation_set: bool = False, ) -> None: - - super().__init__(task, transform) - + """Create Folder Folder Dataset. + + Args: + normal_dir (Union[str, Path]): Path to the directory containing normal images. + abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images. + split (Optional[str], optional): Dataset split (ie., either train or test). Defaults to None. + pre_process (Optional[PreProcessor], optional): Image Pro-processor to apply transform. + Defaults to None. + normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing + normal images for the test dataset. 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.2. + mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing + the mask annotations. Defaults to None. + extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the + directory. + task (Optional[str], optional): Task type. (classification or segmentation) Defaults to None. + 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. + Those wanting to create a validation set could set this flag to ``True``. + + Raises: + ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is + provided, `task` should be set to `segmentation`. + + """ 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_folder_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, + if task == "segmentation" and mask_dir is None: + warnings.warn( + "Segmentation task is requested, but mask directory is not provided. " + "Classification is to be chosen if mask directory is not provided." + ) + self.task = "classification" + + if task == "classification" and mask_dir: + warnings.warn( + "Classification task is requested, but mask directory is provided. " + "Segmentation task is to be chosen if mask directory is provided." + ) + self.task = "segmentation" + + if task is None or mask_dir is None: + self.task = "classification" + else: + self.task = task + + self.pre_process = pre_process + self.samples = make_dataset( + normal_dir=normal_dir, + abnormal_dir=abnormal_dir, + normal_test_dir=normal_test_dir, + mask_dir=mask_dir, + split=split, + split_ratio=split_ratio, + seed=seed, + create_validation_set=create_validation_set, + extensions=extensions, ) + def __len__(self) -> int: + """Get length of the dataset.""" + return len(self.samples) -class Folder(AnomalibDataModule): - """Folder DataModule. + def __getitem__(self, index: int) -> Dict[str, Union[str, Tensor]]: + """Get dataset item for the index ``index``. - 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. - """ + Args: + index (int): Index to get the item. + + Returns: + Union[Dict[str, Tensor], Dict[str, Union[str, Tensor]]]: Dict of image tensor during training. + Otherwise, Dict containing image path, target path, image tensor, label and transformed bounding box. + """ + item: Dict[str, Union[str, Tensor]] = {} + + image_path = self.samples.image_path[index] + image = read_image(image_path) + + pre_processed = self.pre_process(image=image) + item = {"image": pre_processed["image"]} + + if self.split in ["val", "test"]: + label_index = self.samples.label_index[index] + + item["image_path"] = image_path + item["label"] = label_index + + if self.task == "segmentation": + mask_path = self.samples.mask_path[index] + + # Only Anomalous (1) images has masks in MVTec AD dataset. + # 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 + + pre_processed = self.pre_process(image=image, mask=mask) + + item["mask_path"] = mask_path + item["image"] = pre_processed["image"] + item["mask"] = pre_processed["mask"] + + return item + + +@DATAMODULE_REGISTRY +class Folder(LightningDataModule): + """Folder Lightning Data Module.""" 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, - normal_split_ratio: float = 0.2, - 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, + root: Union[str, Path], + normal_dir: str = "normal", + abnormal_dir: str = "abnormal", + task: str = "classification", + normal_test_dir: Optional[Union[Path, str]] = None, + mask_dir: Optional[Union[Path, str]] = None, + extensions: Optional[Tuple[str, ...]] = None, + split_ratio: float = 0.2, + seed: Optional[int] = None, + image_size: Optional[Union[int, Tuple[int, int]]] = None, train_batch_size: int = 32, - eval_batch_size: int = 32, + test_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, + transform_config_train: Optional[Union[str, A.Compose]] = None, + transform_config_val: Optional[Union[str, A.Compose]] = None, + create_validation_set: bool = False, ) -> 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, + """Folder Dataset PL Datamodule. + + Args: + root (Union[str, Path]): Path to the root folder containing normal and abnormal dirs. + normal_dir (str, optional): Name of the directory containing normal images. + Defaults to "normal". + abnormal_dir (str, optional): Name of the directory containing abnormal images. + Defaults to "abnormal". + task (str, optional): Task type. Could be either classification or segmentation. + Defaults to "classification". + normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing + normal images for the test dataset. Defaults to None. + mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing + the mask annotations. Defaults to None. + extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the + directory. 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.2. + seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0. + image_size (Optional[Union[int, Tuple[int, int]]], optional): Size of the input image. + Defaults to None. + 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. + transform_config_train (Optional[Union[str, A.Compose]], optional): Config for pre-processing + during training. + Defaults to None. + transform_config_val (Optional[Union[str, A.Compose]], optional): Config for pre-processing + during validation. + Defaults to None. + create_validation_set (bool, optional):Boolean to create a validation set from the test set. + Those wanting to create a validation set could set this flag to ``True``. + + Examples: + Assume that we use Folder Dataset for the MVTec/bottle/broken_large category. We would do: + >>> from anomalib.data import Folder + >>> datamodule = Folder( + ... root="./datasets/MVTec/bottle/test", + ... normal="good", + ... abnormal="broken_large", + ... image_size=256 + ... ) + >>> datamodule.setup() + >>> i, data = next(enumerate(datamodule.train_dataloader())) + >>> data["image"].shape + torch.Size([16, 3, 256, 256]) + + >>> i, test_data = next(enumerate(datamodule.test_dataloader())) + >>> test_data.keys() + dict_keys(['image']) + + We could also create a Folder DataModule for datasets containing mask annotations. + The dataset expects that mask annotation filenames must be same as the original filename. + To this end, we modified mask filenames in MVTec AD bottle category. + Now we could try folder data module using the mvtec bottle broken large category + >>> datamodule = Folder( + ... root="./datasets/bottle/test", + ... normal="good", + ... abnormal="broken_large", + ... mask_dir="./datasets/bottle/ground_truth/broken_large", + ... image_size=256 + ... ) + + >>> i , train_data = next(enumerate(datamodule.train_dataloader())) + >>> train_data.keys() + dict_keys(['image']) + >>> train_data["image"].shape + torch.Size([16, 3, 256, 256]) + + >>> i, test_data = next(enumerate(datamodule.test_dataloader())) + dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask']) + >>> print(test_data["image"].shape, test_data["mask"].shape) + torch.Size([24, 3, 256, 256]) torch.Size([24, 256, 256]) + + By default, Folder Data Module does not create a validation set. If a validation set + is needed it could be set as follows: + + >>> datamodule = Folder( + ... root="./datasets/bottle/test", + ... normal="good", + ... abnormal="broken_large", + ... mask_dir="./datasets/bottle/ground_truth/broken_large", + ... image_size=256, + ... create_validation_set=True, + ... ) + + >>> i, val_data = next(enumerate(datamodule.val_dataloader())) + >>> val_data.keys() + dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask']) + >>> print(val_data["image"].shape, val_data["mask"].shape) + torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256]) + + >>> i, test_data = next(enumerate(datamodule.test_dataloader())) + >>> print(test_data["image"].shape, test_data["mask"].shape) + torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256]) + + """ + super().__init__() + + if seed is None and normal_test_dir is None: + raise ValueError( + "Both seed and normal_test_dir cannot be None." + " When seed is not set, images from the normal directory are split between training and test dir." + " This will lead to inconsistency between runs." + ) + + self.root = _check_and_convert_path(root) + self.normal_dir = self.root / normal_dir + self.abnormal_dir = self.root / abnormal_dir + self.normal_test = normal_test_dir + if normal_test_dir: + self.normal_test = self.root / normal_test_dir + self.mask_dir = mask_dir + self.extensions = extensions + self.split_ratio = split_ratio + + if task == "classification" and mask_dir is not None: + raise ValueError( + "Classification type is set but mask_dir provided. " + "If mask_dir is provided task type must be segmentation. " + "Check your configuration." + ) + self.task = task + self.transform_config_train = transform_config_train + self.transform_config_val = transform_config_val + self.image_size = image_size + + if self.transform_config_train is not None and self.transform_config_val is None: + self.transform_config_val = self.transform_config_train + + self.pre_process_train = PreProcessor(config=self.transform_config_train, image_size=self.image_size) + self.pre_process_val = PreProcessor(config=self.transform_config_val, image_size=self.image_size) + + self.train_batch_size = train_batch_size + self.test_batch_size = test_batch_size + self.num_workers = num_workers + + self.create_validation_set = create_validation_set + self.seed = seed + + self.train_data: Dataset + self.test_data: Dataset + if create_validation_set: + self.val_data: Dataset + self.inference_data: Dataset + + def setup(self, stage: Optional[str] = None) -> None: + """Setup train, validation and test data. + + Args: + stage: Optional[str]: Train/Val/Test stages. (Default value = None) + + """ + logger.info("Setting up train, validation, test and prediction datasets.") + if stage in (None, "fit"): + self.train_data = FolderDataset( + normal_dir=self.normal_dir, + abnormal_dir=self.abnormal_dir, + normal_test_dir=self.normal_test, + split="train", + split_ratio=self.split_ratio, + mask_dir=self.mask_dir, + pre_process=self.pre_process_train, + extensions=self.extensions, + task=self.task, + seed=self.seed, + create_validation_set=self.create_validation_set, + ) + + if self.create_validation_set: + self.val_data = FolderDataset( + normal_dir=self.normal_dir, + abnormal_dir=self.abnormal_dir, + normal_test_dir=self.normal_test, + split="val", + split_ratio=self.split_ratio, + mask_dir=self.mask_dir, + pre_process=self.pre_process_val, + extensions=self.extensions, + task=self.task, + seed=self.seed, + create_validation_set=self.create_validation_set, + ) + + self.test_data = FolderDataset( + normal_dir=self.normal_dir, + abnormal_dir=self.abnormal_dir, + split="test", + normal_test_dir=self.normal_test, + split_ratio=self.split_ratio, + mask_dir=self.mask_dir, + pre_process=self.pre_process_val, + extensions=self.extensions, + task=self.task, + seed=self.seed, + create_validation_set=self.create_validation_set, ) - self.normal_split_ratio = normal_split_ratio + if stage == "predict": + self.inference_data = InferenceDataset( + path=self.root, image_size=self.image_size, transform_config=self.transform_config_val + ) - 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 = FolderDataset( - 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, - ) + def train_dataloader(self) -> TRAIN_DATALOADERS: + """Get train dataloader.""" + return DataLoader(self.train_data, shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers) - self.test_data = FolderDataset( - 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, - ) + def val_dataloader(self) -> EVAL_DATALOADERS: + """Get validation dataloader.""" + dataset = self.val_data if self.create_validation_set else self.test_data + return DataLoader(dataset=dataset, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers) -if __name__ == "__main__": - import pandas as pd - - pd.set_option('display.max_columns', None) - pd.set_option('display.max_rows', None) - pd.set_option("display.width", 2000) - pd.set_option('display.max_colwidth', None) - from albumentations.pytorch import ToTensorV2 - - augment = A.to_dict( - A.Compose( - [ - A.Resize(height=256, width=256, always_apply=True), - # A.HorizontalFlip(p=0.5), - A.VerticalFlip(p=0.5), - A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), - A.ShiftScaleRotate(p=0.9), - # A.ToGray(always_apply=True), - A.RandomBrightnessContrast(p=0.3), - A.Blur(blur_limit=[5, 5], always_apply=True), - # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), - ToTensorV2(), - ], - additional_targets={"image": "image", "depth_image": "image"}, - ), - ) - folder_dataset_root = Path("C:/Users/REH/anomalib/datasets/mvtec3d") - - mvtec_3d = Folder( - root=folder_dataset_root , - normal_dir=folder_dataset_root / "bagel/train/good/rgb", - abnormal_dir= folder_dataset_root / "bagel/test/combined/rgb", - normal_test_dir=folder_dataset_root / "bagel/test/good/rgb", - mask_dir=folder_dataset_root / "bagel/test/combined/gt", - normal_depth_dir=folder_dataset_root / "bagel/train/good/xyz", - abnormal_depth_dir=folder_dataset_root / "bagel/test/combined/xyz",# - normal_test_depth_dir=folder_dataset_root /"bagel/test/good/xyz", - image_size=256, - transform_config_train=A.from_dict(augment), - transform_config_eval=A.from_dict(augment), - ) - mvtec_3d.setup() - # print(mvtec_3d.train_data.samples) - i, data = next(enumerate(mvtec_3d.train_dataloader())) - #data = mvtec_3d.test_data[3] - print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') - print(data["depth_image"].shape) - i, data = next(enumerate(mvtec_3d.test_dataloader())) - print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') - print(data["depth_image"].shape) - - import matplotlib.pyplot as plt - - f, axarr = plt.subplots(3, 1) - axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) - axarr[1].imshow(data["image"].permute(1, 2, 0)) - axarr[2].imshow(data["mask"]) - - plt.show() \ No newline at end of file + def test_dataloader(self) -> EVAL_DATALOADERS: + """Get test dataloader.""" + return DataLoader(self.test_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers) + + def predict_dataloader(self) -> EVAL_DATALOADERS: + """Get predict dataloader.""" + return DataLoader( + self.inference_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers + ) From 0127fe15af14c777b7158819db01bfa952a838b7 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sat, 11 Feb 2023 10:47:01 +0100 Subject: [PATCH 11/21] folder 3d remove test --- anomalib/data/folder_3d.py | 62 +------------------------------------- anomalib/data/mvtec_3d.py | 1 + 2 files changed, 2 insertions(+), 61 deletions(-) diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py index 6373adbfef..ceb9d63099 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -438,64 +438,4 @@ def __init__( normal_test_depth_dir=normal_test_depth_dir, mask_dir=mask_dir, extensions=extensions, - ) - -if __name__ == "__main__": - import pandas as pd - - pd.set_option('display.max_columns', None) - pd.set_option('display.max_rows', None) - pd.set_option("display.width", 2000) - pd.set_option('display.max_colwidth', None) - from albumentations.pytorch import ToTensorV2 - - augment = A.to_dict( - A.Compose( - [ - A.Resize(height=256, width=256, always_apply=True), - # A.HorizontalFlip(p=0.5), - A.VerticalFlip(p=0.5), - A.ElasticTransform(alpha=1.3, sigma=17, alpha_affine=12, p=0.2), - A.ShiftScaleRotate(p=0.9), - # A.ToGray(always_apply=True), - A.RandomBrightnessContrast(p=0.3), - A.Blur(blur_limit=[5, 5], always_apply=True), - # A.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)), - ToTensorV2(), - ], - additional_targets={"image": "image", "depth_image": "image"}, - ), - ) - folder_dataset_root = Path("C:/Users/REH/anomalib/datasets/mvtec3d") - - mvtec_3d = Folder3D( - root=folder_dataset_root , - normal_dir=folder_dataset_root / "bagel/train/good/rgb", - abnormal_dir= folder_dataset_root / "bagel/test/combined/rgb", - normal_test_dir=folder_dataset_root / "bagel/test/good/rgb", - mask_dir=folder_dataset_root / "bagel/test/combined/gt", - normal_depth_dir=folder_dataset_root / "bagel/train/good/xyz", - abnormal_depth_dir=folder_dataset_root / "bagel/test/combined/xyz",# - normal_test_depth_dir=folder_dataset_root /"bagel/test/good/xyz", - image_size=256, - transform_config_train=A.from_dict(augment), - transform_config_eval=A.from_dict(augment), - ) - mvtec_3d.setup() - # print(mvtec_3d.train_data.samples) - i, data = next(enumerate(mvtec_3d.train_dataloader())) - #data = mvtec_3d.test_data[3] - print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') - print(data["depth_image"].shape) - i, data = next(enumerate(mvtec_3d.test_dataloader())) - print(f'Image Shape: {data["image"].shape} Mask Shape: {data["mask"].shape}') - print(data["depth_image"].shape) - - import matplotlib.pyplot as plt - - f, axarr = plt.subplots(3, 1) - axarr[0].imshow(data["depth_image"].permute(1, 2, 0)[:, :, 2]) - axarr[1].imshow(data["image"].permute(1, 2, 0)) - axarr[2].imshow(data["mask"]) - - plt.show() \ No newline at end of file + ) \ No newline at end of file diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 932377abce..6de6d5842b 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -150,6 +150,7 @@ def make_mvtec_3d_dataset( 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 ( From 3494d189a1ff857914a2e02e4b17f8f0ab46da30 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sat, 11 Feb 2023 10:53:30 +0100 Subject: [PATCH 12/21] fix typings --- anomalib/data/__init__.py | 4 ++ anomalib/data/base/dataset.py | 2 +- anomalib/data/folder_3d.py | 49 ++++++++++++---------- anomalib/data/mvtec_3d.py | 4 +- notebooks/100_datamodules/103_folder.ipynb | 11 ++--- 5 files changed, 41 insertions(+), 29 deletions(-) diff --git a/anomalib/data/__init__.py b/anomalib/data/__init__.py index 21efccb891..2d4d1cdd87 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 @@ -187,8 +189,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/dataset.py b/anomalib/data/base/dataset.py index 9b49b15446..ef39cccc57 100644 --- a/anomalib/data/base/dataset.py +++ b/anomalib/data/base/dataset.py @@ -126,7 +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/folder_3d.py b/anomalib/data/folder_3d.py index ceb9d63099..c6de618d9f 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -11,7 +11,7 @@ from pathlib import Path import albumentations as A -from pandas import DataFrame +from pandas import DataFrame, isna from torchvision.datasets.folder import IMG_EXTENSIONS from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset @@ -159,7 +159,7 @@ def make_folder_dataset( if normal_test_depth_dir: dirs = {**dirs, **{"normal_test_depth": normal_test_depth_dir}} - + if mask_dir: dirs = {**dirs, **{"mask_dir": mask_dir}} @@ -167,7 +167,7 @@ def make_folder_dataset( filename, label = _prepare_files_labels(path, dir_type, extensions) filenames += filename labels += label - + samples = DataFrame({"image_path": filenames, "label": labels, "mask_path": ""}) samples = samples.sort_values(by="image_path", ignore_index=True) @@ -178,33 +178,38 @@ def make_folder_dataset( # 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 + 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 - - #samples = samples.loc[(samples.label == "normal") | (samples.label == "abnormal") | (samples.label == "normal_test")] - - #samples = samples[pd.isnull(samples['label'])] + samples.loc[samples.label == "normal_test", "depth_path"] = samples.loc[ + samples.label == "normal_test_depth" + ].image_path.values + # make sure all 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')." + 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 pd.isna(x) else True - ).all(), f"missing depth image files" + 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.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 @@ -212,8 +217,10 @@ def make_folder_dataset( 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")] + # 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. @@ -279,7 +286,7 @@ def __init__( split: str | Split | None = None, extensions: tuple[str, ...] | None = None, ) -> None: - + super().__init__(task, transform) self.split = split @@ -409,7 +416,7 @@ def __init__( center_crop=center_crop, normalization=InputNormalizationMethod(normalization), ) - + self.train_data = Folder3DDataset( task=task, transform=transform_train, @@ -438,4 +445,4 @@ def __init__( normal_test_depth_dir=normal_test_depth_dir, mask_dir=mask_dir, extensions=extensions, - ) \ No newline at end of file + ) diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 6de6d5842b..51347f9312 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -160,7 +160,7 @@ def make_mvtec_3d_dataset( ), "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] @@ -290,4 +290,4 @@ def prepare_data(self) -> None: if (self.root / self.category).is_dir(): logger.info("Found the dataset.") else: - download_and_extract(self.root, DOWNLOAD_INFO) \ No newline at end of file + download_and_extract(self.root, DOWNLOAD_INFO) diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb index 984bc2b3f4..f2105dcfd0 100644 --- a/notebooks/100_datamodules/103_folder.ipynb +++ b/notebooks/100_datamodules/103_folder.ipynb @@ -34,7 +34,7 @@ " root_directory = current_directory / \"anomalib\"\n", "\n", "os.chdir(root_directory)\n", - "folder_dataset_root = root_directory / \"datasets\" / \"MVTec\" /\"hazelnut\"" + "folder_dataset_root = root_directory / \"datasets\" / \"MVTec\" / \"hazelnut\"" ] }, { @@ -143,10 +143,11 @@ ], "source": [ "import pandas as pd\n", - "pd.set_option('display.max_columns', None)\n", - "pd.set_option('display.max_rows', None)\n", + "\n", + "pd.set_option(\"display.max_columns\", None)\n", + "pd.set_option(\"display.max_rows\", None)\n", "pd.set_option(\"display.width\", 2000)\n", - "pd.set_option('display.max_colwidth', None)\n", + "pd.set_option(\"display.max_colwidth\", None)\n", "\n", "\n", "folder_datamodule = Folder(\n", @@ -154,7 +155,7 @@ " normal_dir=\"train/good\",\n", " abnormal_dir=\"test/crack\",\n", " task=\"segmentation\",\n", - " mask_dir=folder_dataset_root / \"ground_truth\" /\"crack\",\n", + " mask_dir=folder_dataset_root / \"ground_truth\" / \"crack\",\n", " image_size=256,\n", " normalization=InputNormalizationMethod.NONE, # don't apply normalization, as we want to visualize the images\n", ")\n", From 468efbb2bf738fe59ba714c7fd4652c2dcded00e Mon Sep 17 00:00:00 2001 From: Alexander Riedel <54716527+alexriedel1@users.noreply.github.com> Date: Wed, 15 Feb 2023 18:52:52 +0100 Subject: [PATCH 13/21] fix debugging artefacts --- .pre-commit-config.yaml | 16 ++++++++-------- anomalib/data/__init__.py | 18 ++++++++++++++++++ anomalib/data/base/dataset.py | 2 +- anomalib/data/mvtec_3d.py | 3 +-- 4 files changed, 28 insertions(+), 11 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d5ab119d32..aacdd3ab9b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -77,15 +77,15 @@ repos: - id: nbqa-flake8 - id: nbqa-pylint - #- repo: https://github.com/pre-commit/mirrors-prettier - # rev: v2.7.1 - # hooks: - # - id: prettier + - repo: https://github.com/pre-commit/mirrors-prettier + rev: v2.7.1 + hooks: + - id: prettier - #- repo: https://github.com/igorshubovych/markdownlint-cli - # rev: v0.32.2 - # hooks: - # - id: markdownlint + - repo: https://github.com/igorshubovych/markdownlint-cli + rev: v0.32.2 + hooks: + - id: markdownlint - repo: https://github.com/AleksaC/hadolint-py rev: v2.10.0 diff --git a/anomalib/data/__init__.py b/anomalib/data/__init__.py index 2d4d1cdd87..6c9fbdd3dd 100644 --- a/anomalib/data/__init__.py +++ b/anomalib/data/__init__.py @@ -61,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, diff --git a/anomalib/data/base/dataset.py b/anomalib/data/base/dataset.py index ef39cccc57..3a4a14798a 100644 --- a/anomalib/data/base/dataset.py +++ b/anomalib/data/base/dataset.py @@ -119,7 +119,7 @@ def __getitem__(self, index: int) -> dict[str, str | Tensor]: image = read_image(image_path) item = dict(image_path=image_path, label=label_index) - print(mask_path, label_index) + if self.task == TaskType.CLASSIFICATION: transformed = self.transform(image=image) item["image"] = transformed["image"] diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index 51347f9312..a8efd86c56 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -50,8 +50,7 @@ name="mvtec_3d", url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832" "/mvtec_3d_anomaly_detection.tar.xz", - hash="", -) + hash="d8bb2800fbf3ac88e798da6ae10dc819",) def make_mvtec_3d_dataset( From e7d1a53834a7018beac14636df912c64a0835512 Mon Sep 17 00:00:00 2001 From: Alexander Riedel <54716527+alexriedel1@users.noreply.github.com> Date: Wed, 15 Feb 2023 19:04:24 +0100 Subject: [PATCH 14/21] original folder --- anomalib/data/folder.py | 641 ++++++++++++++-------------------------- 1 file changed, 230 insertions(+), 411 deletions(-) diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index 0f3b47adbd..d0a7892abc 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -6,38 +6,30 @@ # Copyright (C) 2022 Intel Corporation # SPDX-License-Identifier: Apache-2.0 -import logging -import warnings +from __future__ import annotations + from pathlib import Path -from typing import Dict, Optional, Tuple, Union import albumentations as A -import cv2 -import numpy as np -from pandas.core.frame import DataFrame -from pytorch_lightning.core.datamodule import LightningDataModule -from pytorch_lightning.utilities.cli import DATAMODULE_REGISTRY -from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS -from torch import Tensor -from torch.utils.data import DataLoader, Dataset +from pandas import DataFrame from torchvision.datasets.folder import IMG_EXTENSIONS -from anomalib.data.inference import InferenceDataset -from anomalib.data.utils import read_image -from anomalib.data.utils.split import ( - create_validation_set_from_test_set, - split_normal_images_in_train_set, +from anomalib.data.base import AnomalibDataModule, AnomalibDataset +from anomalib.data.task_type import TaskType +from anomalib.data.utils import ( + InputNormalizationMethod, + Split, + TestSplitMode, + ValSplitMode, + get_transforms, ) -from anomalib.pre_processing import PreProcessor - -logger = logging.getLogger(__name__) -def _check_and_convert_path(path: Union[str, Path]) -> Path: +def _check_and_convert_path(path: str | Path) -> Path: """Check an input path, and convert to Pathlib object. Args: - path (Union[str, Path]): Input path. + path (str | Path): Input path. Returns: Path: Output path converted to pathlib object. @@ -48,14 +40,14 @@ def _check_and_convert_path(path: Union[str, Path]) -> Path: def _prepare_files_labels( - path: Union[str, Path], path_type: str, extensions: Optional[Tuple[str, ...]] = None -) -> Tuple[list, list]: + 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 (Union[str, Path]): Path to the directory containing images. + path (str | Path): Path to the directory containing images. path_type (str): Type of images in the provided path ("normal", "abnormal", "normal_test") - extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the + extensions (tuple[str, ...] | None, optional): Type of the image extensions to read from the directory. Returns: @@ -69,7 +61,7 @@ def _prepare_files_labels( extensions = (extensions,) filenames = [f for f in path.glob(r"**/*") if f.suffix in extensions and not f.is_dir()] - if len(filenames) == 0: + if not filenames: raise RuntimeError(f"Found 0 {path_type} images in {path}") labels = [path_type] * len(filenames) @@ -77,44 +69,70 @@ def _prepare_files_labels( return filenames, labels -def make_dataset( - normal_dir: Union[str, Path], - abnormal_dir: Union[str, Path], - normal_test_dir: Optional[Union[str, Path]] = None, - mask_dir: Optional[Union[str, Path]] = None, - split: Optional[str] = None, - split_ratio: float = 0.2, - seed: Optional[int] = None, - create_validation_set: bool = True, - extensions: Optional[Tuple[str, ...]] = None, -): +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 + + +def make_folder_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, + split: str | Split | None = None, + extensions: tuple[str, ...] | None = None, +) -> DataFrame: """Make Folder Dataset. Args: - normal_dir (Union[str, Path]): Path to the directory containing normal images. - abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images. - normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing + 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 (Optional[Union[str, Path]], optional): Path to the directory containing + mask_dir (str | Path | None, optional): Path to the directory containing the mask annotations. Defaults to None. - split (Optional[str], 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.2. - 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. - Those wanting to create a validation set could set this flag to ``True``. - extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the + 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 + assert normal_dir.is_dir(), "A folder location must be provided in normal_dir." filenames = [] labels = [] - dirs = {"normal": normal_dir, "abnormal": abnormal_dir} + dirs = {"normal": normal_dir} + + if abnormal_dir: + dirs = {**dirs, **{"abnormal": abnormal_dir}} if normal_test_dir: dirs = {**dirs, **{"normal_test": normal_test_dir}} @@ -124,7 +142,7 @@ def make_dataset( filenames += filename labels += label - samples = DataFrame({"image_path": filenames, "label": labels}) + samples = DataFrame({"image_path": filenames, "label": labels, "mask_path": ""}) # Create label index for normal (0) and abnormal (1) images. samples.loc[(samples.label == "normal") | (samples.label == "normal_test"), "label_index"] = 0 @@ -134,10 +152,16 @@ def make_dataset( # 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) - samples["mask_path"] = "" for index, row in samples.iterrows(): if row.label_index == 1: - samples.loc[index, "mask_path"] = str(mask_dir / row.image_path.name) + 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}" # Ensure the pathlib objects are converted to str. # This is because torch dataloader doesn't like pathlib. @@ -149,390 +173,185 @@ def make_dataset( samples.loc[(samples.label == "normal"), "split"] = "train" samples.loc[(samples.label == "abnormal") | (samples.label == "normal_test"), "split"] = "test" - if not normal_test_dir: - samples = split_normal_images_in_train_set( - samples=samples, split_ratio=split_ratio, seed=seed, normal_label="normal" - ) - - # If `create_validation_set` is set to True, the test set is split into half. - if create_validation_set: - samples = create_validation_set_from_test_set(samples, seed=seed, normal_label="normal") - # Get the data frame for the split. - if split is not None and split in ["train", "val", "test"]: + if split: samples = samples[samples.split == split] samples = samples.reset_index(drop=True) return samples -class FolderDataset(Dataset): - """Folder Dataset.""" +class FolderDataset(AnomalibDataset): + """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. + + 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, - normal_dir: Union[Path, str], - abnormal_dir: Union[Path, str], - split: str, - pre_process: PreProcessor, - normal_test_dir: Optional[Union[Path, str]] = None, - split_ratio: float = 0.2, - mask_dir: Optional[Union[Path, str]] = None, - extensions: Optional[Tuple[str, ...]] = None, - task: Optional[str] = None, - seed: Optional[int] = None, - create_validation_set: bool = False, + 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, + split: str | Split | None = None, + extensions: tuple[str, ...] | None = None, ) -> None: - """Create Folder Folder Dataset. - - Args: - normal_dir (Union[str, Path]): Path to the directory containing normal images. - abnormal_dir (Union[str, Path]): Path to the directory containing abnormal images. - split (Optional[str], optional): Dataset split (ie., either train or test). Defaults to None. - pre_process (Optional[PreProcessor], optional): Image Pro-processor to apply transform. - Defaults to None. - normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing - normal images for the test dataset. 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.2. - mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing - the mask annotations. Defaults to None. - extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the - directory. - task (Optional[str], optional): Task type. (classification or segmentation) Defaults to None. - 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. - Those wanting to create a validation set could set this flag to ``True``. - - Raises: - ValueError: When task is set to classification and `mask_dir` is provided. When `mask_dir` is - provided, `task` should be set to `segmentation`. - - """ + 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.extensions = extensions - if task == "segmentation" and mask_dir is None: - warnings.warn( - "Segmentation task is requested, but mask directory is not provided. " - "Classification is to be chosen if mask directory is not provided." - ) - self.task = "classification" - - if task == "classification" and mask_dir: - warnings.warn( - "Classification task is requested, but mask directory is provided. " - "Segmentation task is to be chosen if mask directory is provided." - ) - self.task = "segmentation" - - if task is None or mask_dir is None: - self.task = "classification" - else: - self.task = task - - self.pre_process = pre_process - self.samples = make_dataset( - normal_dir=normal_dir, - abnormal_dir=abnormal_dir, - normal_test_dir=normal_test_dir, - mask_dir=mask_dir, - split=split, - split_ratio=split_ratio, - seed=seed, - create_validation_set=create_validation_set, - extensions=extensions, + def _setup(self) -> None: + """Assign samples.""" + self.samples = make_folder_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, + split=self.split, + extensions=self.extensions, ) - def __len__(self) -> int: - """Get length of the dataset.""" - return len(self.samples) - - def __getitem__(self, index: int) -> Dict[str, Union[str, Tensor]]: - """Get dataset item for the index ``index``. - - Args: - index (int): Index to get the item. - - Returns: - Union[Dict[str, Tensor], Dict[str, Union[str, Tensor]]]: Dict of image tensor during training. - Otherwise, Dict containing image path, target path, image tensor, label and transformed bounding box. - """ - item: Dict[str, Union[str, Tensor]] = {} - image_path = self.samples.image_path[index] - image = read_image(image_path) +class Folder(AnomalibDataModule): + """Folder DataModule. - pre_processed = self.pre_process(image=image) - item = {"image": pre_processed["image"]} - - if self.split in ["val", "test"]: - label_index = self.samples.label_index[index] - - item["image_path"] = image_path - item["label"] = label_index - - if self.task == "segmentation": - mask_path = self.samples.mask_path[index] - - # Only Anomalous (1) images has masks in MVTec AD dataset. - # 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 - - pre_processed = self.pre_process(image=image, mask=mask) - - item["mask_path"] = mask_path - item["image"] = pre_processed["image"] - item["mask"] = pre_processed["mask"] - - return item - - -@DATAMODULE_REGISTRY -class Folder(LightningDataModule): - """Folder Lightning Data Module.""" + 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_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, - root: Union[str, Path], - normal_dir: str = "normal", - abnormal_dir: str = "abnormal", - task: str = "classification", - normal_test_dir: Optional[Union[Path, str]] = None, - mask_dir: Optional[Union[Path, str]] = None, - extensions: Optional[Tuple[str, ...]] = None, - split_ratio: float = 0.2, - seed: Optional[int] = None, - image_size: Optional[Union[int, Tuple[int, int]]] = None, + 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_split_ratio: float = 0.2, + 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, - test_batch_size: int = 32, + eval_batch_size: int = 32, num_workers: int = 8, - transform_config_train: Optional[Union[str, A.Compose]] = None, - transform_config_val: Optional[Union[str, A.Compose]] = None, - create_validation_set: bool = False, + 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: - """Folder Dataset PL Datamodule. - - Args: - root (Union[str, Path]): Path to the root folder containing normal and abnormal dirs. - normal_dir (str, optional): Name of the directory containing normal images. - Defaults to "normal". - abnormal_dir (str, optional): Name of the directory containing abnormal images. - Defaults to "abnormal". - task (str, optional): Task type. Could be either classification or segmentation. - Defaults to "classification". - normal_test_dir (Optional[Union[str, Path]], optional): Path to the directory containing - normal images for the test dataset. Defaults to None. - mask_dir (Optional[Union[str, Path]], optional): Path to the directory containing - the mask annotations. Defaults to None. - extensions (Optional[Tuple[str, ...]], optional): Type of the image extensions to read from the - directory. 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.2. - seed (int, optional): Random seed to ensure reproducibility when splitting. Defaults to 0. - image_size (Optional[Union[int, Tuple[int, int]]], optional): Size of the input image. - Defaults to None. - 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. - transform_config_train (Optional[Union[str, A.Compose]], optional): Config for pre-processing - during training. - Defaults to None. - transform_config_val (Optional[Union[str, A.Compose]], optional): Config for pre-processing - during validation. - Defaults to None. - create_validation_set (bool, optional):Boolean to create a validation set from the test set. - Those wanting to create a validation set could set this flag to ``True``. - - Examples: - Assume that we use Folder Dataset for the MVTec/bottle/broken_large category. We would do: - >>> from anomalib.data import Folder - >>> datamodule = Folder( - ... root="./datasets/MVTec/bottle/test", - ... normal="good", - ... abnormal="broken_large", - ... image_size=256 - ... ) - >>> datamodule.setup() - >>> i, data = next(enumerate(datamodule.train_dataloader())) - >>> data["image"].shape - torch.Size([16, 3, 256, 256]) - - >>> i, test_data = next(enumerate(datamodule.test_dataloader())) - >>> test_data.keys() - dict_keys(['image']) - - We could also create a Folder DataModule for datasets containing mask annotations. - The dataset expects that mask annotation filenames must be same as the original filename. - To this end, we modified mask filenames in MVTec AD bottle category. - Now we could try folder data module using the mvtec bottle broken large category - >>> datamodule = Folder( - ... root="./datasets/bottle/test", - ... normal="good", - ... abnormal="broken_large", - ... mask_dir="./datasets/bottle/ground_truth/broken_large", - ... image_size=256 - ... ) - - >>> i , train_data = next(enumerate(datamodule.train_dataloader())) - >>> train_data.keys() - dict_keys(['image']) - >>> train_data["image"].shape - torch.Size([16, 3, 256, 256]) - - >>> i, test_data = next(enumerate(datamodule.test_dataloader())) - dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask']) - >>> print(test_data["image"].shape, test_data["mask"].shape) - torch.Size([24, 3, 256, 256]) torch.Size([24, 256, 256]) - - By default, Folder Data Module does not create a validation set. If a validation set - is needed it could be set as follows: - - >>> datamodule = Folder( - ... root="./datasets/bottle/test", - ... normal="good", - ... abnormal="broken_large", - ... mask_dir="./datasets/bottle/ground_truth/broken_large", - ... image_size=256, - ... create_validation_set=True, - ... ) - - >>> i, val_data = next(enumerate(datamodule.val_dataloader())) - >>> val_data.keys() - dict_keys(['image_path', 'label', 'mask_path', 'image', 'mask']) - >>> print(val_data["image"].shape, val_data["mask"].shape) - torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256]) - - >>> i, test_data = next(enumerate(datamodule.test_dataloader())) - >>> print(test_data["image"].shape, test_data["mask"].shape) - torch.Size([12, 3, 256, 256]) torch.Size([12, 256, 256]) - - """ - super().__init__() - - if seed is None and normal_test_dir is None: - raise ValueError( - "Both seed and normal_test_dir cannot be None." - " When seed is not set, images from the normal directory are split between training and test dir." - " This will lead to inconsistency between runs." - ) - - self.root = _check_and_convert_path(root) - self.normal_dir = self.root / normal_dir - self.abnormal_dir = self.root / abnormal_dir - self.normal_test = normal_test_dir - if normal_test_dir: - self.normal_test = self.root / normal_test_dir - self.mask_dir = mask_dir - self.extensions = extensions - self.split_ratio = split_ratio - - if task == "classification" and mask_dir is not None: - raise ValueError( - "Classification type is set but mask_dir provided. " - "If mask_dir is provided task type must be segmentation. " - "Check your configuration." - ) - self.task = task - self.transform_config_train = transform_config_train - self.transform_config_val = transform_config_val - self.image_size = image_size - - if self.transform_config_train is not None and self.transform_config_val is None: - self.transform_config_val = self.transform_config_train - - self.pre_process_train = PreProcessor(config=self.transform_config_train, image_size=self.image_size) - self.pre_process_val = PreProcessor(config=self.transform_config_val, image_size=self.image_size) - - self.train_batch_size = train_batch_size - self.test_batch_size = test_batch_size - self.num_workers = num_workers - - self.create_validation_set = create_validation_set - self.seed = seed - - self.train_data: Dataset - self.test_data: Dataset - if create_validation_set: - self.val_data: Dataset - self.inference_data: Dataset - - def setup(self, stage: Optional[str] = None) -> None: - """Setup train, validation and test data. - - Args: - stage: Optional[str]: Train/Val/Test stages. (Default value = None) - - """ - logger.info("Setting up train, validation, test and prediction datasets.") - if stage in (None, "fit"): - self.train_data = FolderDataset( - normal_dir=self.normal_dir, - abnormal_dir=self.abnormal_dir, - normal_test_dir=self.normal_test, - split="train", - split_ratio=self.split_ratio, - mask_dir=self.mask_dir, - pre_process=self.pre_process_train, - extensions=self.extensions, - task=self.task, - seed=self.seed, - create_validation_set=self.create_validation_set, - ) - - if self.create_validation_set: - self.val_data = FolderDataset( - normal_dir=self.normal_dir, - abnormal_dir=self.abnormal_dir, - normal_test_dir=self.normal_test, - split="val", - split_ratio=self.split_ratio, - mask_dir=self.mask_dir, - pre_process=self.pre_process_val, - extensions=self.extensions, - task=self.task, - seed=self.seed, - create_validation_set=self.create_validation_set, - ) - - self.test_data = FolderDataset( - normal_dir=self.normal_dir, - abnormal_dir=self.abnormal_dir, - split="test", - normal_test_dir=self.normal_test, - split_ratio=self.split_ratio, - mask_dir=self.mask_dir, - pre_process=self.pre_process_val, - extensions=self.extensions, - task=self.task, - seed=self.seed, - create_validation_set=self.create_validation_set, + 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, ) - if stage == "predict": - self.inference_data = InferenceDataset( - path=self.root, image_size=self.image_size, transform_config=self.transform_config_val - ) - - def train_dataloader(self) -> TRAIN_DATALOADERS: - """Get train dataloader.""" - return DataLoader(self.train_data, shuffle=True, batch_size=self.train_batch_size, num_workers=self.num_workers) + self.normal_split_ratio = normal_split_ratio - def val_dataloader(self) -> EVAL_DATALOADERS: - """Get validation dataloader.""" - dataset = self.val_data if self.create_validation_set else self.test_data - return DataLoader(dataset=dataset, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers) + 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), + ) - def test_dataloader(self) -> EVAL_DATALOADERS: - """Get test dataloader.""" - return DataLoader(self.test_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers) + self.train_data = FolderDataset( + 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, + extensions=extensions, + ) - def predict_dataloader(self) -> EVAL_DATALOADERS: - """Get predict dataloader.""" - return DataLoader( - self.inference_data, shuffle=False, batch_size=self.test_batch_size, num_workers=self.num_workers + self.test_data = FolderDataset( + task=task, + transform=transform_eval, + split=Split.TEST, + root=root, + normal_dir=normal_dir, + abnormal_dir=abnormal_dir, + normal_test_dir=normal_test_dir, + mask_dir=mask_dir, + extensions=extensions, ) From f057d59bb6577832847273e9bb054f6d2af57b49 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sun, 26 Feb 2023 16:04:27 +0100 Subject: [PATCH 15/21] depth map classification visualizer, add CLI --- anomalib/data/__init__.py | 25 +++++++++++++++++++++++++ anomalib/data/folder_3d.py | 3 --- anomalib/data/mvtec_3d.py | 3 ++- anomalib/post_processing/visualizer.py | 3 ++- 4 files changed, 29 insertions(+), 5 deletions(-) diff --git a/anomalib/data/__init__.py b/anomalib/data/__init__.py index 6c9fbdd3dd..c2f3be9b03 100644 --- a/anomalib/data/__init__.py +++ b/anomalib/data/__init__.py @@ -119,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, diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py index c6de618d9f..7aa3f128b6 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -374,7 +374,6 @@ def __init__( normal_depth_dir: str | Path | None = None, abnormal_depth_dir: str | Path | None = None, normal_test_depth_dir: str | Path | None = None, - normal_split_ratio: float = 0.2, extensions: tuple[str] | None = None, image_size: int | tuple[int, int] | None = None, center_crop: int | tuple[int, int] | None = None, @@ -402,8 +401,6 @@ def __init__( seed=seed, ) - self.normal_split_ratio = normal_split_ratio - transform_train = get_transforms( config=transform_config_train, image_size=image_size, diff --git a/anomalib/data/mvtec_3d.py b/anomalib/data/mvtec_3d.py index a8efd86c56..6cf6369202 100644 --- a/anomalib/data/mvtec_3d.py +++ b/anomalib/data/mvtec_3d.py @@ -50,7 +50,8 @@ name="mvtec_3d", url="https://www.mydrive.ch/shares/45920/dd1eb345346df066c63b5c95676b961b/download/428824485-1643285832" "/mvtec_3d_anomaly_detection.tar.xz", - hash="d8bb2800fbf3ac88e798da6ae10dc819",) + hash="d8bb2800fbf3ac88e798da6ae10dc819", +) def make_mvtec_3d_dataset( diff --git a/anomalib/post_processing/visualizer.py b/anomalib/post_processing/visualizer.py index 10b2f31d6e..ae6c1a604d 100644 --- a/anomalib/post_processing/visualizer.py +++ b/anomalib/post_processing/visualizer.py @@ -161,7 +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") - visualization.add_image(image_result.heat_map, "Predicted Heat Map") + 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: From 2e982582b870e767a0a82f7bbcadac53826cbe19 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sun, 26 Feb 2023 22:39:06 +0100 Subject: [PATCH 16/21] folder logic same as folder_3d logic --- .pre-commit-config.yaml | 16 ++++++++-------- anomalib/data/folder.py | 37 ++++++++++++++++++++++++------------- anomalib/data/folder_3d.py | 2 +- 3 files changed, 33 insertions(+), 22 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index aacdd3ab9b..d5ab119d32 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -77,15 +77,15 @@ repos: - id: nbqa-flake8 - id: nbqa-pylint - - repo: https://github.com/pre-commit/mirrors-prettier - rev: v2.7.1 - hooks: - - id: prettier + #- repo: https://github.com/pre-commit/mirrors-prettier + # rev: v2.7.1 + # hooks: + # - id: prettier - - repo: https://github.com/igorshubovych/markdownlint-cli - rev: v0.32.2 - hooks: - - id: markdownlint + #- repo: https://github.com/igorshubovych/markdownlint-cli + # rev: v0.32.2 + # hooks: + # - id: markdownlint - repo: https://github.com/AleksaC/hadolint-py rev: v2.10.0 diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index d0a7892abc..e66babc8b2 100644 --- a/anomalib/data/folder.py +++ b/anomalib/data/folder.py @@ -137,31 +137,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 index 7aa3f128b6..97ed428ac8 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -168,7 +168,7 @@ def make_folder_dataset( 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. From 6f3d894cb35207814befb356de75d7e665ad6fe1 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Sun, 26 Feb 2023 22:40:02 +0100 Subject: [PATCH 17/21] pre commit --- .pre-commit-config.yaml | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index d5ab119d32..aacdd3ab9b 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -77,15 +77,15 @@ repos: - id: nbqa-flake8 - id: nbqa-pylint - #- repo: https://github.com/pre-commit/mirrors-prettier - # rev: v2.7.1 - # hooks: - # - id: prettier + - repo: https://github.com/pre-commit/mirrors-prettier + rev: v2.7.1 + hooks: + - id: prettier - #- repo: https://github.com/igorshubovych/markdownlint-cli - # rev: v0.32.2 - # hooks: - # - id: markdownlint + - repo: https://github.com/igorshubovych/markdownlint-cli + rev: v0.32.2 + hooks: + - id: markdownlint - repo: https://github.com/AleksaC/hadolint-py rev: v2.10.0 From 7e10fd49922b7327cac901d3d3d903c4a0e6fc24 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Wed, 1 Mar 2023 15:31:01 +0100 Subject: [PATCH 18/21] notebook reset, typo, move functions --- anomalib/data/folder.py | 70 +- anomalib/data/folder_3d.py | 76 +- anomalib/data/utils/__init__.py | 4 + notebooks/100_datamodules/103_folder.ipynb | 862 ++++++++++++++------- 4 files changed, 609 insertions(+), 403 deletions(-) diff --git a/anomalib/data/folder.py b/anomalib/data/folder.py index e66babc8b2..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( diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py index 97ed428ac8..2770326424 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -12,7 +12,6 @@ import albumentations as A from pandas import DataFrame, isna -from torchvision.datasets.folder import IMG_EXTENSIONS from anomalib.data.base import AnomalibDataModule, AnomalibDepthDataset from anomalib.data.task_type import TaskType @@ -23,77 +22,10 @@ ValSplitMode, get_transforms, ) +from anomalib.data.utils.path import _prepare_files_labels, _resolve_path -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 - - -def make_folder_dataset( +def make_folder3d_dataset( normal_dir: str | Path, root: str | Path | None = None, abnormal_dir: str | Path | None = None, @@ -190,7 +122,7 @@ def make_folder_dataset( samples.label == "normal_test_depth" ].image_path.values - # make sure all every rgb image has a corresponding depth image and that the file exists + # 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) @@ -302,7 +234,7 @@ def __init__( def _setup(self) -> None: """Assign samples.""" - self.samples = make_folder_dataset( + self.samples = make_folder3d_dataset( root=self.root, normal_dir=self.normal_dir, abnormal_dir=self.abnormal_dir, diff --git a/anomalib/data/utils/__init__.py b/anomalib/data/utils/__init__.py index bfbca7c516..bbd8ac6689 100644 --- a/anomalib/data/utils/__init__.py +++ b/anomalib/data/utils/__init__.py @@ -14,6 +14,7 @@ read_depth_image, read_image, ) +from .path import _check_and_convert_path, _prepare_files_labels, _resolve_path from .split import ( Split, TestSplitMode, @@ -45,4 +46,7 @@ "InputNormalizationMethod", "download_and_extract", "DownloadInfo", + "_check_and_convert_path", + "_prepare_files_labels", + "_resolve_path", ] diff --git a/notebooks/100_datamodules/103_folder.ipynb b/notebooks/100_datamodules/103_folder.ipynb index f2105dcfd0..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": 1, - "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\" / \"MVTec\" / \"hazelnut\"" - ] - }, - { - "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", @@ -54,392 +17,772 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "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" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " image_path label mask_path label_index split\n", - "0 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\001.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\001_mask.png 1 test\n", - "1 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\006.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\006_mask.png 1 test\n", - "2 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\007.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\007_mask.png 1 test\n", - "3 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\009.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\009_mask.png 1 test\n", - "4 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\010.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\010_mask.png 1 test\n", - "5 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\011.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\011_mask.png 1 test\n", - "6 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\013.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\013_mask.png 1 test\n", - "7 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\014.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\014_mask.png 1 test\n", - "8 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\test\\crack\\016.png abnormal c:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\ground_truth\\crack\\016_mask.png 1 test\n", - "9 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\000.png normal 0 train\n", - "10 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\022.png normal 0 train\n", - "11 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\038.png normal 0 train\n", - "12 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\040.png normal 0 train\n", - "13 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\044.png normal 0 train\n", - "14 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\045.png normal 0 train\n", - "15 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\059.png normal 0 train\n", - "16 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\066.png normal 0 train\n", - "17 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\069.png normal 0 train\n", - "18 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\080.png normal 0 train\n", - "19 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\082.png normal 0 train\n", - "20 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\100.png normal 0 train\n", - "21 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\125.png normal 0 train\n", - "22 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\127.png normal 0 train\n", - "23 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\138.png normal 0 train\n", - "24 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\146.png normal 0 train\n", - "25 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\147.png normal 0 train\n", - "26 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\156.png normal 0 train\n", - "27 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\160.png normal 0 train\n", - "28 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\174.png normal 0 train\n", - "29 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\180.png normal 0 train\n", - "30 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\185.png normal 0 train\n", - "31 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\195.png normal 0 train\n", - "32 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\212.png normal 0 train\n", - "33 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\224.png normal 0 train\n", - "34 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\243.png normal 0 train\n", - "35 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\246.png normal 0 train\n", - "36 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\250.png normal 0 train\n", - "37 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\268.png normal 0 train\n", - "38 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\285.png normal 0 train\n", - "39 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\292.png normal 0 train\n", - "40 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\314.png normal 0 train\n", - "41 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\318.png normal 0 train\n", - "42 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\321.png normal 0 train\n", - "43 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\352.png normal 0 train\n", - "44 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\354.png normal 0 train\n", - "45 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\371.png normal 0 train\n", - "46 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\372.png normal 0 train\n", - "47 C:\\Users\\REH\\anomalib\\datasets\\MVTec\\hazelnut\\train\\good\\384.png normal 0 train\n" - ] - } - ], + "outputs": [], "source": [ - "import pandas as pd\n", - "\n", - "pd.set_option(\"display.max_columns\", None)\n", - "pd.set_option(\"display.max_rows\", None)\n", - "pd.set_option(\"display.width\", 2000)\n", - "pd.set_option(\"display.max_colwidth\", None)\n", - "\n", - "\n", - "folder_datamodule = Folder(\n", - " root=folder_dataset_root,\n", - " normal_dir=\"train/good\",\n", - " abnormal_dir=\"test/crack\",\n", - " task=\"segmentation\",\n", - " mask_dir=folder_dataset_root / \"ground_truth\" / \"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": "markdown", + "metadata": {}, + "source": [ + "To create `FolderDataset` we need to import `pre_process` that applies transforms to the input image." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask']) torch.Size([32, 3, 256, 256])\n" - ] - } - ], + "outputs": [], "source": [ - "# Train images\n", - "i, data = next(enumerate(folder_datamodule.train_dataloader()))\n", - "print(data.keys(), data[\"image\"].shape)" + "PreProcessor??" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "dict_keys(['image_path', 'label', 'image', 'mask_path', 'mask']) torch.Size([32, 3, 256, 256]) torch.Size([32, 256, 256])\n" - ] - } - ], + "outputs": [], "source": [ - "# Test images\n", - "i, data = next(enumerate(folder_datamodule.test_dataloader()))\n", - "print(data.keys(), data[\"image\"].shape, data[\"mask\"].shape)" + "pre_process = PreProcessor(image_size=256, to_tensor=True)" ] }, { "cell_type": "markdown", "metadata": {}, "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." + "#### Classification Task" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "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": 10, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "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))))" - ] - }, - { - "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." + "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" }, @@ -455,12 +798,7 @@ "pygments_lexer": "ipython3", "version": "3.8.12" }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "1fd01f0f7bed3bf30e7776b25350aa77bee0815d858f4fbea6a39e3e49268879" - } - } + "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 From 116a734651c57bc4e23a12acbeeebe1b63066337 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Wed, 1 Mar 2023 15:32:04 +0100 Subject: [PATCH 19/21] files added --- anomalib/data/utils/path.py | 77 +++++++++++++++++++++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 anomalib/data/utils/path.py diff --git a/anomalib/data/utils/path.py b/anomalib/data/utils/path.py new file mode 100644 index 0000000000..2ccbdb4fa7 --- /dev/null +++ b/anomalib/data/utils/path.py @@ -0,0 +1,77 @@ +"""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 \ No newline at end of file From 2ff30276a4e6225983d847c897a3a1efdb3139fe Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Wed, 1 Mar 2023 19:03:31 +0100 Subject: [PATCH 20/21] pre commit fixing --- anomalib/data/utils/path.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/anomalib/data/utils/path.py b/anomalib/data/utils/path.py index 2ccbdb4fa7..8ad38da150 100644 --- a/anomalib/data/utils/path.py +++ b/anomalib/data/utils/path.py @@ -6,6 +6,7 @@ from __future__ import annotations from pathlib import Path + from torchvision.datasets.folder import IMG_EXTENSIONS @@ -74,4 +75,4 @@ def _resolve_path(folder: str | Path, root: str | Path | None = None) -> Path: else: # root provided; prepend root and return absolute path path = (Path(root) / folder).resolve() - return path \ No newline at end of file + return path From 1b33a555c17ad1441ce4a197eb2c8dc6c47f2b70 Mon Sep 17 00:00:00 2001 From: alexriedel1 Date: Wed, 1 Mar 2023 19:07:53 +0100 Subject: [PATCH 21/21] new pre commits --- anomalib/data/folder_3d.py | 1 - 1 file changed, 1 deletion(-) diff --git a/anomalib/data/folder_3d.py b/anomalib/data/folder_3d.py index 2770326424..d4c7f8f1f6 100644 --- a/anomalib/data/folder_3d.py +++ b/anomalib/data/folder_3d.py @@ -218,7 +218,6 @@ def __init__( split: str | Split | None = None, extensions: tuple[str, ...] | None = None, ) -> None: - super().__init__(task, transform) self.split = split