How did the tiler predict？

[wenwu2021]

transform = Compose([
    Resize(size=(256, 256)),

])
dataset = PredictDataset(
    path=r"D:\BaiduNetdiskDownload\Zbar\AnomalibTensorrtAlg\x64\Debug\result\033.png",
    transform=transform,
)
# transform = Compose([
#     Resize(size=(256, 256))
# ])
pre_processor = PreProcessor(transform=transform)
# datamodule = MVTecAD(root=r"D:\BaiduNetdiskDownload\Zbar\anomalib-2.0.0\datasets\MVTecAD\tile\test",
#                      category="good",
#                      train_batch_size= 1,
#                      eval_batch_size=1,
#                      num_workers=0)
# model = Patchcore()
# # prepare tiling configuration callback
model = Patchcore(pre_processor=pre_processor)
# tiler_config_callback = TilerConfigurationCallback(enable=True, tile_size=[128, 128], stride=64)
#
# # pass the tiling configuration callback to the engine
# engine = Engine(callbacks=[tiler_config_callback])
engine = Engine()




# train the model (tiling is seamlessly utilized in the background)
predictions=engine.predict(dataset=dataset,
               model=model,
               ckpt_path=r"D:\BaiduNetdiskDownload\anomalib\anomalib-2.0.0\results\Patchcore\MVTecAD\tile\v4\weights\lightning\model.ckpt")

# 5. Access the results
if predictions is not None:
    for prediction in predictions:
        image_path = prediction.image_path
        print(image_path)
        anomaly_map = prediction.anomaly_map  # Pixel-level anomaly heatmap
        pred_label = prediction.pred_label  # Image-level label (0: normal, 1: anomalous)
        pred_score = prediction.pred_score  # Image-level anomaly score
        print(pred_score)

How did the tiler predict？How is the preprocessing done? Does it involve division by 255?

[alfieroddan]

Not completely clear but from your issue but I'm guessing you want to know how the tiler works and its effect as a pre-processing step.

How did the tiler predict？

The main documentation for the Tiler can be found here. The purpose of the tiler is to split up an image into smaller images, then we have a batch of smaller images for the model to predict.

From the docs here is an example:

from anomalib.data.utils.tiler import Tiler
import torch
# Create tiler with 256x256 tiles and 128 stride
tiler = Tiler(tile_size=256, stride=128)
# Create sample 512x512 image
image = torch.rand(1, 3, 512, 512)
# Generate tiles
tiles = tiler.tile(image)
tiles.shape

# Reconstruct image from tiles
reconstructed = tiler.untile(tiles)
reconstructed.shape

How is the preprocessing done?

The PreProcessor docs can be found here.

Each model will have its own PreProcessor default, as an example here is Patchcore's. But if you want to define your own you can do so like you have done:

from torchvision.transforms.v2 import Compose, Resize
from anomalib.pre_processing import PreProcessor
transform = Compose([Resize(size=(256, 256))])
pre_processor = PreProcessor(transform=transform)

Does it involve division by 255?

It depends on the Dataset and PreProcessing you use. In your example you are using PredictDataset, this reads the image and converts it to a tensor for prediction. In this loading it calls read_iamge which converts to [0,1].

[wenwu2021]

you mean PreProcessor is converts to [0,1], division by 255

[alfieroddan]

No it is done in the dataset class.