I'm experiencing discrepancies in the results when testing the same image using engine.test compared to TorchInferencer.predict.

[tr1ggerone]

I've trained a PatchCore model, but I'm encountering an inconsistency in the results when using engine.test and TorchInferencer.predict on the same image. Below, I've included my code for review.

Additionally, I'm facing a configuration issue: setting max_epoch=10 directly in the Engine configuration doesn't seem to take effect, whereas using Trainer.max_epochs=10 works as expected. Could you help clarify why this might be happening?

Here is my code

# %% -- import module --
import os
import torch
import shutil
import numpy as np
import pandas as pd
from pathlib import Path
from lightning.pytorch.trainer import Trainer
from pytorch_lightning import seed_everything
from lightning.pytorch.callbacks import EarlyStopping
from lightning.pytorch.callbacks import ModelCheckpoint

import anomalib
from anomalib.data.image.folder import Folder
from anomalib.engine import Engine
from anomalib.models import Patchcore
from anomalib import TaskType
from anomalib.deploy import ExportType

from torchvision import transforms
print(anomalib.__version__)
seed_everything(0)

# %% -- Setting up the Dataset Directory --
transform = transforms.Compose([
    transforms.Resize((256, 386)),
    # transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])

folder_datamodule = Folder(
    name = "IDRiD_B",
    normal_dir = "dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0",
    abnormal_dir = "dataset/IDRiD_B/Training_Set_Retinopathy_abnormal_grade_4",
    task = TaskType.CLASSIFICATION,
    train_batch_size = 16,
    eval_batch_size = 16,
    num_workers = 8,
    # image_size=(256, 256),
    transform = transform,
)
folder_datamodule.setup()

dataloader_tra = folder_datamodule.train_dataloader()
dataloader_val = folder_datamodule.val_dataloader()
dataloader_tes = folder_datamodule.test_dataloader()

# %% -- prepare model --
model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)

callbacks = [ModelCheckpoint(mode = "max", monitor = "image_F1Score"),
             EarlyStopping(monitor = "image_AUROC", mode = "max", patience = 5)]
Trainer.max_epochs = 10
Trainer(accelerator='gpu')
Trainer.precision = 32
torch.set_float32_matmul_precision('medium')

engine = Engine(
    # callbacks = callbacks,
    logger = False,
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
    default_root_dir = Path("result_batch16_epoch10"),
)

engine.fit(model, train_dataloaders = dataloader_tra, val_dataloaders = dataloader_val)

test_results = engine.test(model, dataloaders = dataloader_tes,
                           ckpt_path = engine.trainer.checkpoint_callback.best_model_path)

path_list = engine.trainer.checkpoint_callback.best_model_path.split('\\')
engine.export(model, ExportType.TORCH, export_root="/".join(path_list[6:9]))

# %% -- TorchInferencer --
from anomalib.deploy import TorchInferencer
from torchvision import transforms
from PIL import Image
from matplotlib import pyplot as plt
%matplotlib inline

image_path = "dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0/IDRiD_305_0.jpg"
inferencer = TorchInferencer(path="result_batch16_epoch10/Patchcore/v0/weights/torch/model.pt")

transform = transforms.Compose([
    transforms.Resize((256, 386)),
    transforms.ToTensor()])
img = Image.open(image_path)
img_t = transform(img)

predictions = inferencer.predict(image=img_t)
print(predictions.pred_score, predictions.pred_label)

plt.imshow(predictions.heat_map)

• the result in image folder
  
• the result inferenced by pytorch model
  

[abc-125]

Additionally, I'm facing a configuration issue: setting max_epoch=10 directly in the Engine configuration doesn't seem to take effect, whereas using Trainer.max_epochs=10 works as expected. Could you help clarify why this might be happening?

PatchCore should be trained for one epoch only, according to the paper. It just extracts features from the training dataset in one iteration and then compares them to the new data. For this reason, there is a hardcoded max_epochs = 1 for this model, which might overwrite some of the manual settings.

[tr1ggerone]

Thank you for your explanation, I understood after reading the paper. So, even if I change the dataset or use transfer learning, under the PatchCore architecture, it only need to train for one epoch, right?

[abc-125]

Yes, it is always 1 epoch for PatchCore. It is not a training in a usual meaning, weights are not changed, just the features from the training data are extracted to a memory bank.

[tr1ggerone]

Thank you for answering~~

[samet-akcay]

@tr1ggerone, can you try using Engine.predict for the inference? I wonder if you will get the same results or not. We will need to refactor TorchInferencer a bit within the upcoming versions.

[tr1ggerone]

OK, i will try to use Engine.predict tomorrow. Before i try, is it appropriate to construct the dataset in this way before testing.

from torch.utils.data import DataLoader
from anomalib.data import PredictDataset

inference_dataset = PredictDataset(path="dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0/IDRiD_305_0.jpg")
inference_dataloader = DataLoader(dataset=inference_dataset)

model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)
engine = Engine(
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
)
predictions = engine.predict(model=model, dataloaders=inference_dataloader, ckpt_path="Patchcore/v1/weight/model.ckpt")

[tr1ggerone]

@samet-akcay Here is the detailed description of the test. Please help to check if the steps are appropriate. I suspect the issue stems from the image preprocessing or eval_transform, as the image sizes produced by the two different inference methods do not match the size specified in transforms.Compose.
The results from engine.predict and TorchInferencer are the same in terms of pred_score and pred_labes; the only difference is the image size.

hardware detail

• Intel Core i5-13500HX
• RTX 4070 Latptop GPU
• Windows 10
• 32GB RAM

setup python env, based on anomalib version 1.0.1

conda create -n env_openvivo python=3.11.8
conda activate env_openvivo

pip install anomalib
anomalib install
pip install openpyxl

test code, run as administrator

import module

import os
import torch
import shutil
import numpy as np
import pandas as pd
from pathlib import Path
from lightning.pytorch.trainer import Trainer
from lightning.pytorch.callbacks import EarlyStopping
from lightning.pytorch.callbacks import ModelCheckpoint

import anomalib
from anomalib.data.image.folder import Folder
from anomalib.engine import Engine
from anomalib.models import Patchcore
from anomalib import TaskType
from anomalib.deploy import ExportType

import torchvision.transforms.v2 as transforms
print(anomalib.__version__)
torch.set_float32_matmul_precision('medium')

Setting up the Dataset Directory

transform = transforms.Compose([
    transforms.Resize(size=(256, 386)),
    transforms.Normalize(mean=[0, 0, 0], std=[1, 1, 1])
])

folder_datamodule = Folder(
    name = "IDRiD_B",
    normal_dir = "dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0",
    abnormal_dir = "dataset/IDRiD_B/Training_Set_Retinopathy_abnormal_grade_4",
    task = TaskType.CLASSIFICATION,
    train_batch_size = 16,
    eval_batch_size = 16,
    num_workers = 8,
    transform = transform,
    train_transform = transform,
    eval_transform = transform,
    seed = 42
)

folder_datamodule.setup()
dataloader_tra = folder_datamodule.train_dataloader()
dataloader_val = folder_datamodule.val_dataloader()
dataloader_tes = folder_datamodule.test_dataloader()

# -- check transform worked or not --
for batch in dataloader_tra:
    first_batch = batch
    break
print("first batch size in dataloader_tra:", first_batch['image'].shape)

data_transfrom = first_batch['image'][0, 0, :, :]
print("Max value:", torch.max(data_transfrom))
print("Min value:", torch.min(data_transfrom))
print("Mean:", torch.mean(data_transfrom))
print("Standard Deviation:", torch.std(data_transfrom))

• cell output
  • first batch size in dataloader_tra: torch.Size([16, 3, 256, 386])
  • Max value: tensor(1.)
  • Min value: tensor(0.)
  • Mean: tensor(0.3114)
  • Standard Deviation: tensor(0.2206)

Prepare Model

model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)
engine = Engine(
    logger = False,
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
    default_root_dir = Path("result_batch16_epoch10"),
    accelerator = 'gpu',
    precision = 32
)

Fit and Test

engine.fit(model, train_dataloaders = dataloader_tra, val_dataloaders = dataloader_val)
test_results = engine.test(model, dataloaders = dataloader_tes,
                           ckpt_path = engine.trainer.checkpoint_callback.best_model_path)

• cell ouput
  

Export model

path_list = engine.trainer.checkpoint_callback.best_model_path.split('\\')
engine.export(model, ExportType.TORCH, export_root = "/".join(path_list[6:9]))

• cell output
  • WindowsPath('result_batch16_epoch10/Patchcore/v1/weights/torch/model.pt')

Inference same image, this image ( DRiD_396) is labeled as normal in original dataset

The result from engine.test has the same size as I defined in transforms.Compose.

Result in TorchInferencer

from anomalib.deploy import TorchInferencer
from matplotlib import pyplot as plt
from PIL import Image
from time import time
%matplotlib inline

image_path = "dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0/IDRiD_396_0.jpg"
inferencer = TorchInferencer(path="result_batch16_epoch10/Patchcore/v1/weights/torch/model.pt",
                             device='gpu')

T = time()
predictions = inferencer.predict(image=image_path)
print(f"Time in predict image: {time()-T :.2f}")

print(predictions.pred_score, predictions.pred_label)
plt.imshow(predictions.heat_map)
plt.axis('off')

• cell output
  • Size of heatmap：(-0.5, 4287.5, 2847.5, -0.5)
  • pred_score：0.6012670993804932, pred_label：LabelName.ABNORMAL
    

Result in engine.predict

from time import time
from anomalib.data import PredictDataset
from torch.utils.data import DataLoader

model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)
engine = Engine(
    logger = False,
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
    default_root_dir = Path("result_batch16_epoch10_predict"),
    accelerator = 'gpu',
    precision = 32
)

# -- generate dataloader --
image_path = "dataset/IDRiD_B/Training_Set_Retinopathy_normal_grade_0/IDRiD_396_0.jpg"

T = time()
inference_dataset = PredictDataset(path = image_path, image_size = (256, 386))
inference_dataloader = DataLoader(dataset = inference_dataset, num_workers = 8, persistent_workers = True)
print(f"Time in prepare dataloder: {time()-T :.2f}")

T = time()
predictions = engine.predict(model = model, dataloaders = inference_dataloader,
                             ckpt_path = "result_batch16_epoch10/Patchcore/v1/weights/lightning/model.ckpt")
print(f"Time in predict image: {time()-T :.2f}")

• cell output
  • Size of heatmap：(-0.5, 223.5, 223.5, -0.5)
    

[tr1ggerone]

@samet-akcay
Hi, I conducted additional tests with TorchInferencer in torch_inferencer.py and found that the image size specified in eval_transform didn't work as expected. Therefore, I wrote a new function in the TorchInferencer class to address this issue. Below is the source code:

  def predict_override(self, image: str | Path, metadata: dict[str, Any] | None = None,
                       resize: tuple = (224, 224)) -> ImageResult:
      import torch
      from PIL import Image
      import torchvision.transforms.v2 as transforms

      if metadata is None:
          metadata = self.metadata if hasattr(self, "metadata") else {}
      if isinstance(image, str | Path):
          transform = transforms.Compose([
              transforms.Resize(size=resize, antialias=True),
              transforms.Normalize(mean=[0, 0, 0], std=[1, 1, 1])
          ])
          image = Image.open(image).convert("RGB")
          image_tensor = transforms.functional.to_dtype(
              transforms.functional.to_image(image), torch.float32, scale=True)
          image = transform(image_tensor)
      else:
          raise TypeError("only accept srt | Path")
      
      metadata["image_shape"] = image.shape[-2:]
      processed_image = image.unsqueeze(0).to(self.device)
      with torch.no_grad():
          predictions = self.model(processed_image)
      
      output = self.post_process(predictions, metadata=metadata)

      return ImageResult(
          image=(image.numpy().transpose(1, 2, 0) * 255).astype(np.uint8),
          pred_score=output["pred_score"],
          pred_label=output["pred_label"],
          anomaly_map=output["anomaly_map"],
          pred_mask=output["pred_mask"],
          pred_boxes=output["pred_boxes"],
          box_labels=output["box_labels"],
      )

---

Test code of inference

image_path = "dataset/IDRiD_B_grade/Training_Set_Retinopathy_grade_0/0_IDRiD_396.jpg"
weight_ver = "v3"
train_dir = "grade_result_IDRiD_B"
model_path = f"{train_dir}/Patchcore/{weight_ver}/weights/torch/model.pt"
weight_path = f"{train_dir}/Patchcore/{weight_ver}/weights/lightning/model.ckpt"

inferencer = TorchInferencer(path = model_path, device = 'gpu')

for i in range(2):
    T = time()
    if i == 0:
        predictions = inferencer.predict(image = image_path)
    else:
        predictions = inferencer.predict_override(image = image_path, resize=(256, 386))
    print(f"Time in predict image: {time()-T :.2f}")

    print(f"Score: {predictions.pred_score :.4f}, {predictions.pred_label}, {predictions.image.shape}")
    fig, ax = plt.subplots(1, 3, figsize=(15, 5))

    ax[0].imshow(predictions.image)
    ax[0].set_title("Original Image")
    ax[0].axis('off')

    ax[1].imshow(predictions.heat_map)
    ax[1].set_title("predict Heat Map")
    ax[1].axis('off')

    ax[2].imshow(predictions.pred_mask)
    ax[2].set_title("Predict Mask")
    ax[2].axis('off')

---

The Test result

• IDRiD_396_0.jpg in engine.test
  

• IDRiD_396_0.jpg in inferencer.predict_override

  • Time in predict image: 0.20, Score: 0.5282, LabelName.ABNORMAL, (256, 386, 3)
    

• IDRiD_396_0.jpg in inferencer.predict

  • Time in predict image: 0.67, Score: 0.5273, LabelName.ABNORMAL, (2848, 4288, 3)
    

---

Question:

1. The pred_mask in both results did not show any anomaly region, yet the same image is identified as abnormal in the engine.test section. Could there be some issues in determining whether something is normal or abnormal?
2. There's a minor issue in the Folder module: It's recommended to set persistent_workers=True in train_dataloader to speed up the initialization of dataloader workers. However, the current version in datamodule.py does not expose the persistent_workers option. so I hard coding this parameter into the module.

  def train_dataloader(self) -> TRAIN_DATALOADERS:
      """Get train dataloader."""
      return DataLoader(
          dataset=self.train_data,
          shuffle=True,
          batch_size=self.train_batch_size,
          num_workers=self.num_workers,
          persistent_workers=True
      )

[samet-akcay]

@tr1ggerone, can you check the issue again. We have just merged this PR #1953, which, according to @djdameln, should address the problem you are having

[tr1ggerone]

@samet-akcay Thank you for your help. Should I clone the latest version from GitHub, overwrite version 1.0.1, and then run my code again?

[samet-akcay]

Yeah if you run the following, you would have the latest code

# Clone the repository and install in editable mode
git clone https://github.com/openvinotoolkit/anomalib.git
cd anomalib
pip install -e .

[tr1ggerone]

Hi @samet-akcay and @djdameln,

I have conducted tests on version 1.1.0dev, as detailed in PR #1953. The warning message appears when providing either a train_transform or eval_transform independently. Additionally, the issues concerning TorchInferencer and engine.predict remain unresolved. I would like to outline the following concerns:

• The probability outputs pred_score from TorchInferencer (0.5175) and engine.predict (52%) are likely the same, but they differ from those of engine.test (53%).
• The eval_transform does not seem to be effective, as evidenced by the difference in image sizes output by TorchInferencer (2848 x 4288 x 3) and engine.predict (224 x 224 x 3).
• The pred_mask generated by TorchInferencer did not identify any abnormal regions, although the pred_label indicated LabelName.ABNORMAL.

Could you please assist in addressing these discrepancies and provide further guidance?
Thank you for your attention to these matters. Below is my code.

Train a Patchcore model and export it

---

import module

import os
import torch
import shutil
import numpy as np
import pandas as pd
from pathlib import Path

import anomalib
from anomalib.data.image.folder import Folder
from anomalib.engine import Engine
from anomalib.models import Patchcore
from anomalib import TaskType
from anomalib.deploy import ExportType
from anomalib.utils.normalization import NormalizationMethod

import torchvision.transforms.v2 as transforms
print(anomalib.__version__)
torch.set_float32_matmul_precision('medium')

• output: 1.1.0dev

prepare dataset B

image_path = Path("dataset/iDRiD_fully_set/B. Disease Grading/1. Original Images")
label_path = Path("dataset/iDRiD_fully_set/B. Disease Grading/2. Groundtruths")
data_folder = Path("dataset/IDRiD_B_grade")

if not os.path.exists(data_folder):

    # -- Process CSV files to classify images --
    for file_name, dir_name in [("a. IDRiD_Disease Grading_Training Labels.csv", "a. Training Set"),
                                ("b. IDRiD_Disease Grading_Testing Labels.csv", "b. Testing Set")]:
        
        label_csv = pd.read_csv(f"{label_path}/{file_name}")
        header = dir_name.split('.')[-1].strip().split(' ')
        header = '_'.join(header)

        # -- Create directories for normal and abnormal images --
        for level in range(5):
            img_dst = Path(f"{data_folder}/{header}_Retinopathy_grade_{level}")
            img_dst.mkdir(exist_ok=True, parents=True)

            # -- copy data --
            img_data = label_csv[label_csv["Retinopathy grade"] == level]
            for _, img in img_data.iterrows():
                source_path = f"{image_path}/{dir_name}/{img['Image name']}.jpg"
                target_path = f"{img_dst}/{level}_{img['Image name']}.jpg"
                shutil.copy(source_path, target_path)
else:
    print("Data existed")

Setup the dataset with Folder module

transform = transforms.Compose([
    transforms.Resize(size=(256, 386), antialias=True),
    transforms.Normalize(mean=[0, 0, 0], std=[1, 1, 1])
])

folder_datamodule = Folder(
    name = "IDRiD_B_grade",
    normal_dir = "dataset/IDRiD_B_grade/Training_Set_Retinopathy_grade_0",
    abnormal_dir = "dataset/IDRiD_B_grade/Training_Set_Retinopathy_grade_4",
    task = TaskType.CLASSIFICATION,
    train_batch_size = 16,
    eval_batch_size = 16,
    num_workers = 8,
    image_size = (256, 386),
    transform = transform,
    train_transform = transform,
    eval_transform = transform,
    seed = 42
)

folder_datamodule.setup()
dataloader_tra = folder_datamodule.train_dataloader()
dataloader_val = folder_datamodule.val_dataloader()
dataloader_tes = folder_datamodule.test_dataloader()

# -- check transform worked or not --
for batch in dataloader_tra:
    first_batch = batch
    break
print("first batch size in dataloader_tra:", first_batch['image'].shape)

data_transfrom = first_batch['image'][0, 0, :, :]
print("Max value:", torch.max(data_transfrom))
print("Min value:", torch.min(data_transfrom))
print("Mean:", torch.mean(data_transfrom))
print("Standard Deviation:", torch.std(data_transfrom))

• output:

first batch size in dataloader_tra: torch.Size([16, 3, 256, 386])
Max value: tensor(1.0000)
Min value: tensor(0.)
Mean: tensor(0.4039)
Standard Deviation: tensor(0.2904)

Setup model and fit

model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)
engine = Engine(
    normalization = NormalizationMethod.MIN_MAX,
    logger = False,
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
    default_root_dir = "grade_result_IDRiD_B",
    accelerator = 'gpu',
    precision = 32
)

engine.fit(model, train_dataloaders = dataloader_tra, val_dataloaders = dataloader_val)

Test and export model

test_results = engine.test(model, dataloaders = dataloader_tes,
                           ckpt_path = engine.trainer.checkpoint_callback.best_model_path)
path_list = engine.trainer.checkpoint_callback.best_model_path.split('\\')
engine.export(model, ExportType.TORCH, export_root = "/".join(path_list[6:9]))

• output: WindowsPath('grade_result_IDRiD_B/Patchcore/v7/weights/torch/model.pt')
• The result for image ID 0_IDRiD_396 from engine.test
  

Inference image ID 0_IDRiD_396

---

Setup inference parameter

level, img_id = 0, '396'
weight_ver = "v7"
train_dir = "grade_result_IDRiD_B"

image_path = f"dataset/IDRiD_B_grade/Training_Set_Retinopathy_grade_{level}/{level}_IDRiD_{img_id}.jpg"
model_path = f"{train_dir}/Patchcore/{weight_ver}/weights/torch/model.pt"
weight_path = f"{train_dir}/Patchcore/{weight_ver}/weights/lightning/model.ckpt"

Predict by TorchInferencer

from anomalib.deploy import TorchInferencer
from matplotlib import pyplot as plt
from time import time
%matplotlib inline

inferencer = TorchInferencer(path = model_path, device = 'gpu')

T = time()
predictions = inferencer.predict(image = image_path)
# predictions = inferencer.predict_override(image = image_path, resize=(256, 386))
print(f"Time in predict image: {time()-T :.2f}")

print(f"Score: {predictions.pred_score :.4f}, {predictions.pred_label}, {predictions.image.shape}")
fig, ax = plt.subplots(1, 3, figsize=(15, 5))

ax[0].imshow(predictions.image)
ax[0].set_title("Original Image")
ax[0].axis('off')

ax[1].imshow(predictions.heat_map)
ax[1].set_title("predict Heat Map")
ax[1].axis('off')

ax[2].imshow(predictions.pred_mask)
ax[2].set_title("Predict Mask")
ax[2].axis('off')

# -- calculate region --
n, c = np.unique(predictions.pred_mask, return_counts=True)
idx = np.where(n == 255)[0]
if idx.size == 0:
    blob_ratio = 0
else:
    blob_ratio = c[idx][0]/sum(c)
print(f"the abormal region ratio: {blob_ratio :.2f}")

• output
  

Predict by engine.predict

from time import time
from anomalib.data import PredictDataset
from torch.utils.data import DataLoader

model = Patchcore(backbone = "wide_resnet50_2", layers = ("layer2", "layer3"), 
                  pre_trained = True, coreset_sampling_ratio = 0.1, num_neighbors = 9)
engine = Engine(
    logger = False,
    task = TaskType.CLASSIFICATION,
    image_metrics = ["AUROC", "F1Score"], 
    pixel_metrics = ["AUROC", "F1Score"],
    default_root_dir = f"{train_dir}_prdeict",
    accelerator = 'gpu',
    precision = 32
)

# -- generate dataloader --
T = time()
inference_dataset = PredictDataset(path = image_path, image_size = (256, 386))
inference_dataloader = DataLoader(dataset = inference_dataset, num_workers = 8, persistent_workers = True)
print(f"Time in prepare dataloder: {time()-T :.2f}")

T = time()
predictions = engine.predict(model = model, dataloaders = inference_dataloader, ckpt_path = weight_path)
print(f"Time in predict image: {time()-T :.2f}")

• output