From 867cba15e4e8d615e72fcfc7f8e38d7cfd0e0f07 Mon Sep 17 00:00:00 2001 From: Eugene Liu Date: Thu, 29 Feb 2024 10:49:15 +0000 Subject: [PATCH 1/5] fix tile transform and add a test --- src/otx/core/data/dataset/tile.py | 25 +++++++++++++------------ tests/integration/test_tiling.py | 31 +++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 12 deletions(-) diff --git a/src/otx/core/data/dataset/tile.py b/src/otx/core/data/dataset/tile.py index f946869d483..b92619c9d4c 100644 --- a/src/otx/core/data/dataset/tile.py +++ b/src/otx/core/data/dataset/tile.py @@ -6,6 +6,7 @@ from __future__ import annotations import logging as log +from itertools import product from typing import TYPE_CHECKING, Callable import numpy as np @@ -92,22 +93,22 @@ def _extract_rois(self, image: Image) -> list[BboxIntCoords]: img_h, img_w = image.size tile_h, tile_w = self._tile_size h_ovl, w_ovl = self._overlap - stride_h, stride_w = max(int(tile_h * (1 - h_ovl)), 1), max(int(tile_w * (1 - w_ovl)), 1) - n_row, n_col = (img_h + stride_h - 1) // stride_h, (img_w + stride_w - 1) // stride_w rois: list[BboxIntCoords] = [] + cols = range(0, img_w, int(tile_w * (1 - w_ovl))) + rows = range(0, img_h, int(tile_h * (1 - h_ovl))) + + for offset_x, offset_y in product(cols, rows): + x2 = min(offset_x + tile_w, img_w) + y2 = min(offset_y + tile_h, img_h) + c_x, c_y, w, h = x1y1x2y2_to_cxcywh(offset_x, offset_y, x2, y2) + x1, y1, x2, y2 = cxcywh_to_x1y1x2y2(c_x, c_y, w, h) + x1, y1, x2, y2 = clip_x1y1x2y2(x1, y1, x2, y2, img_w, img_h) + x1, y1, x2, y2 = (int(v) for v in [x1, y1, x2, y2]) + rois += [x1y1x2y2_to_xywh(x1, y1, x2, y2)] - for r in range(n_row): - for c in range(n_col): - y1, x1 = stride_h * r, stride_w * c - y2, x2 = y1 + stride_h, x1 + stride_w - - c_x, c_y, w, h = x1y1x2y2_to_cxcywh(x1, y1, x2, y2) - x1, y1, x2, y2 = cxcywh_to_x1y1x2y2(c_x, c_y, w, h) - x1, y1, x2, y2 = clip_x1y1x2y2(x1, y1, x2, y2, img_w, img_h) - rois += [x1y1x2y2_to_xywh(x1, y1, x2, y2)] log.info(f"image: {img_h}x{img_w} ~ tile_size: {self._tile_size}") - log.info(f"{n_row}x{n_col} tiles -> {len(rois)} tiles") + log.info(f"{len(rows)}x{len(cols)} tiles -> {len(rois)} tiles") return rois diff --git a/tests/integration/test_tiling.py b/tests/integration/test_tiling.py index 574d8db14eb..830baeffb64 100644 --- a/tests/integration/test_tiling.py +++ b/tests/integration/test_tiling.py @@ -4,10 +4,16 @@ from __future__ import annotations +from unittest.mock import MagicMock + import numpy as np import pytest from datumaro import Dataset as DmDataset +from datumaro import Image +from datumaro.plugins.tiling.util import xywh_to_x1y1x2y2 from omegaconf import DictConfig, OmegaConf +from openvino.model_api.models import Model +from openvino.model_api.tilers import Tiler from otx.core.config.data import ( DataModuleConfig, SubsetConfig, @@ -84,6 +90,31 @@ def test_tile_transform(self): num_tile_cols = (width + w_stride - 1) // w_stride assert len(tiled_dataset) == (num_tile_rows * num_tile_cols * len(dataset)), "Incorrect number of tiles" + def test_tiler_consistency(self, mocker): + rng = np.random.default_rng() + rnd_tile_size = rng.integers(low=100, high=500) + rnd_tile_overlap = rng.random() + image_size = rng.integers(low=1000, high=5000) + np_image = np.zeros((image_size, image_size, 3), dtype=np.uint8) + dm_image = Image.from_numpy(np_image) + + mock_model = MagicMock(spec=Model) + mocker.patch("openvino.model_api.tilers.tiler.Tiler.__init__", return_value=None) + mocker.patch.multiple(Tiler, __abstractmethods__=set()) + + tiler = Tiler(model=mock_model) + tiler.tile_size = rnd_tile_size + tiler.tiles_overlap = rnd_tile_overlap + + mocker.patch("otx.core.data.dataset.tile.OTXTileTransform.__init__", return_value=None) + tile_transform = OTXTileTransform() + tile_transform._tile_size = (rnd_tile_size, rnd_tile_size) + tile_transform._overlap = (rnd_tile_overlap, rnd_tile_overlap) + + dm_rois = [xywh_to_x1y1x2y2(*roi) for roi in tile_transform._extract_rois(dm_image)] + # 0 index in tiler is the full image so we skip it + assert np.allclose(dm_rois, tiler._tile(np_image)[1:]) + def test_adaptive_tiling(self, fxt_det_data_config): # Enable tile adapter fxt_det_data_config.tile_config.enable_tiler = True From 71ae78976784f076e91ca783e861d128798c786c Mon Sep 17 00:00:00 2001 From: Eugene Liu Date: Thu, 29 Feb 2024 17:59:01 +0000 Subject: [PATCH 2/5] add tests --- src/otx/engine/engine.py | 2 +- tests/integration/test_tiling.py | 66 +++++++++++++++++++++++++++++++- 2 files changed, 66 insertions(+), 2 deletions(-) diff --git a/src/otx/engine/engine.py b/src/otx/engine/engine.py index 5dcd2273ceb..c2a0fa7fd0c 100644 --- a/src/otx/engine/engine.py +++ b/src/otx/engine/engine.py @@ -644,7 +644,7 @@ def from_config( return cls( work_dir=instantiated_config.get("work_dir", work_dir), - datamodule=instantiated_config.get("datamodule"), + datamodule=instantiated_config.get("data"), model=instantiated_config.get("model"), optimizer=instantiated_config.get("optimizer"), scheduler=instantiated_config.get("scheduler"), diff --git a/tests/integration/test_tiling.py b/tests/integration/test_tiling.py index 830baeffb64..cd6134b8efa 100644 --- a/tests/integration/test_tiling.py +++ b/tests/integration/test_tiling.py @@ -4,6 +4,7 @@ from __future__ import annotations +from pathlib import Path from unittest.mock import MagicMock import numpy as np @@ -13,7 +14,7 @@ from datumaro.plugins.tiling.util import xywh_to_x1y1x2y2 from omegaconf import DictConfig, OmegaConf from openvino.model_api.models import Model -from openvino.model_api.tilers import Tiler +from openvino.model_api.tilers import DetectionTiler, InstanceSegmentationTiler, Tiler from otx.core.config.data import ( DataModuleConfig, SubsetConfig, @@ -24,7 +25,10 @@ from otx.core.data.entity.detection import DetBatchDataEntity from otx.core.data.entity.tile import TileBatchDetDataEntity from otx.core.data.module import OTXDataModule +from otx.core.model.entity.detection import OVDetectionModel +from otx.core.model.entity.instance_segmentation import OVInstanceSegmentationModel from otx.core.types.task import OTXTaskType +from otx.engine import Engine class TestOTXTiling: @@ -91,6 +95,7 @@ def test_tile_transform(self): assert len(tiled_dataset) == (num_tile_rows * num_tile_cols * len(dataset)), "Incorrect number of tiles" def test_tiler_consistency(self, mocker): + # Test that the tiler and tile transform are consistent rng = np.random.default_rng() rnd_tile_size = rng.integers(low=100, high=500) rnd_tile_overlap = rng.random() @@ -178,3 +183,62 @@ def test_val_dataloader(self, fxt_det_data_config) -> None: def test_tile_merge(self): pytest.skip("Not implemented yet") + + def test_ov_det_tile_model( + self, + tmp_path: Path, + fxt_accelerator: str, + fxt_target_dataset_per_task: dict, + ): + tile_recipes = [recipe for recipe in pytest.RECIPE_LIST if "detection" in recipe and "tile" in recipe] + tile_recipe = tile_recipes[0] + + engine = Engine.from_config( + config_path=tile_recipe, + data_root=fxt_target_dataset_per_task[OTXTaskType.DETECTION.value.lower()], + work_dir=tmp_path / OTXTaskType.DETECTION, + device=fxt_accelerator, + ) + engine.train(max_epochs=1) + exported_model_path = engine.export() + assert exported_model_path.exists() + engine.test(exported_model_path, accelerator="cpu") + + ov_model = OVDetectionModel(model_name=exported_model_path, num_classes=3) + + assert isinstance(ov_model.model, DetectionTiler), "Model should be an instance of DetectionTiler" + assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size + assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap + + def test_ov_inst_tile_model( + self, + tmp_path: Path, + fxt_accelerator: str, + fxt_target_dataset_per_task: dict, + ): + # Test that tiler is setup correctly for instance segmentation + tile_recipes = [ + recipe for recipe in pytest.RECIPE_LIST if "instance_segmentation" in recipe and "tile" in recipe + ] + + tile_recipe = tile_recipes[0] + + engine = Engine.from_config( + config_path=tile_recipe, + data_root=fxt_target_dataset_per_task[OTXTaskType.INSTANCE_SEGMENTATION.value.lower()], + work_dir=tmp_path / OTXTaskType.INSTANCE_SEGMENTATION, + device=fxt_accelerator, + ) + engine.train(max_epochs=1) + exported_model_path = engine.export() + assert exported_model_path.exists() + engine.test(exported_model_path, accelerator="cpu") + + ov_model = OVInstanceSegmentationModel(model_name=exported_model_path, num_classes=3) + + assert isinstance( + ov_model.model, + InstanceSegmentationTiler, + ), "Model should be an instance of InstanceSegmentationTiler" + assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size + assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap From cd5871b2810720efd8d07d7f747b48ebc991b81c Mon Sep 17 00:00:00 2001 From: Eugene Liu Date: Fri, 1 Mar 2024 14:29:15 +0000 Subject: [PATCH 3/5] update test --- tests/integration/test_tiling.py | 76 ++++++++++++++++---------------- 1 file changed, 37 insertions(+), 39 deletions(-) diff --git a/tests/integration/test_tiling.py b/tests/integration/test_tiling.py index cd6134b8efa..1cd19be6874 100644 --- a/tests/integration/test_tiling.py +++ b/tests/integration/test_tiling.py @@ -191,24 +191,23 @@ def test_ov_det_tile_model( fxt_target_dataset_per_task: dict, ): tile_recipes = [recipe for recipe in pytest.RECIPE_LIST if "detection" in recipe and "tile" in recipe] - tile_recipe = tile_recipes[0] - - engine = Engine.from_config( - config_path=tile_recipe, - data_root=fxt_target_dataset_per_task[OTXTaskType.DETECTION.value.lower()], - work_dir=tmp_path / OTXTaskType.DETECTION, - device=fxt_accelerator, - ) - engine.train(max_epochs=1) - exported_model_path = engine.export() - assert exported_model_path.exists() - engine.test(exported_model_path, accelerator="cpu") - - ov_model = OVDetectionModel(model_name=exported_model_path, num_classes=3) - - assert isinstance(ov_model.model, DetectionTiler), "Model should be an instance of DetectionTiler" - assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size - assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap + for tile_recipe in tile_recipes: + engine = Engine.from_config( + config_path=tile_recipe, + data_root=fxt_target_dataset_per_task[OTXTaskType.DETECTION.value.lower()], + work_dir=tmp_path / OTXTaskType.DETECTION, + device=fxt_accelerator, + ) + engine.train(max_epochs=1) + exported_model_path = engine.export() + assert exported_model_path.exists() + engine.test(exported_model_path, accelerator="cpu") + + ov_model = OVDetectionModel(model_name=exported_model_path, num_classes=3) + + assert isinstance(ov_model.model, DetectionTiler), "Model should be an instance of DetectionTiler" + assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size + assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap def test_ov_inst_tile_model( self, @@ -221,24 +220,23 @@ def test_ov_inst_tile_model( recipe for recipe in pytest.RECIPE_LIST if "instance_segmentation" in recipe and "tile" in recipe ] - tile_recipe = tile_recipes[0] - - engine = Engine.from_config( - config_path=tile_recipe, - data_root=fxt_target_dataset_per_task[OTXTaskType.INSTANCE_SEGMENTATION.value.lower()], - work_dir=tmp_path / OTXTaskType.INSTANCE_SEGMENTATION, - device=fxt_accelerator, - ) - engine.train(max_epochs=1) - exported_model_path = engine.export() - assert exported_model_path.exists() - engine.test(exported_model_path, accelerator="cpu") - - ov_model = OVInstanceSegmentationModel(model_name=exported_model_path, num_classes=3) - - assert isinstance( - ov_model.model, - InstanceSegmentationTiler, - ), "Model should be an instance of InstanceSegmentationTiler" - assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size - assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap + for tile_recipe in tile_recipes: + engine = Engine.from_config( + config_path=tile_recipe, + data_root=fxt_target_dataset_per_task[OTXTaskType.INSTANCE_SEGMENTATION.value.lower()], + work_dir=tmp_path / OTXTaskType.INSTANCE_SEGMENTATION, + device=fxt_accelerator, + ) + engine.train(max_epochs=1) + exported_model_path = engine.export() + assert exported_model_path.exists() + engine.test(exported_model_path, accelerator="cpu") + + ov_model = OVInstanceSegmentationModel(model_name=exported_model_path, num_classes=3) + + assert isinstance( + ov_model.model, + InstanceSegmentationTiler, + ), "Model should be an instance of InstanceSegmentationTiler" + assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size + assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap From 0e9e355020dd67131d30ab3ea3e1eb6dc179993f Mon Sep 17 00:00:00 2001 From: Eugene Liu Date: Mon, 4 Mar 2024 09:53:42 +0000 Subject: [PATCH 4/5] modify tile tests --- tests/integration/api/test_engine_api.py | 32 ++++++++ tests/integration/conftest.py | 2 + tests/integration/test_tiling.py | 93 ------------------------ tests/unit/core/utils/test_tile.py | 58 +++++++++++++++ 4 files changed, 92 insertions(+), 93 deletions(-) create mode 100644 tests/unit/core/utils/test_tile.py diff --git a/tests/integration/api/test_engine_api.py b/tests/integration/api/test_engine_api.py index f18e8bf9c50..a0c8cc421c5 100644 --- a/tests/integration/api/test_engine_api.py +++ b/tests/integration/api/test_engine_api.py @@ -4,6 +4,7 @@ from pathlib import Path import pytest +from openvino.model_api.tilers import Tiler from otx.core.data.module import OTXDataModule from otx.core.model.entity.base import OTXModel from otx.core.types.task import OTXTaskType @@ -71,3 +72,34 @@ def test_engine_from_config( if task in OVMODEL_PER_TASK: test_metric_from_ov_model = engine.test(checkpoint=exported_model_path, accelerator="cpu") assert len(test_metric_from_ov_model) > 0 + + +@pytest.mark.parametrize("recipe", pytest.TILE_RECIPE_LIST) +def test_engine_from_tile_recipe( + recipe: str, + tmp_path: Path, + fxt_accelerator: str, + fxt_target_dataset_per_task: dict, +): + task = OTXTaskType.DETECTION if "detection" in recipe else OTXTaskType.INSTANCE_SEGMENTATION + + engine = Engine.from_config( + config_path=recipe, + data_root=fxt_target_dataset_per_task[task.value.lower()], + work_dir=tmp_path / task, + device=fxt_accelerator, + ) + engine.train(max_epochs=1) + exported_model_path = engine.export() + assert exported_model_path.exists() + metric = engine.test(exported_model_path, accelerator="cpu") + assert len(metric) > 0 + + # Check OVModel & OVTiler is set correctly + ov_model = engine._auto_configurator.get_ov_model( + model_name=exported_model_path, + label_info=engine.datamodule.label_info, + ) + assert isinstance(ov_model.model, Tiler), "Model should be an instance of Tiler" + assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size + assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap diff --git a/tests/integration/conftest.py b/tests/integration/conftest.py index 94c40c05411..6360f29b6bd 100644 --- a/tests/integration/conftest.py +++ b/tests/integration/conftest.py @@ -97,10 +97,12 @@ def pytest_configure(config): target_recipe_list.extend(recipe_list) target_ov_recipe_list.extend(recipe_ov_list) + tile_recipe_list = [recipe for recipe in target_recipe_list if "tile" in recipe] pytest.TASK_LIST = task_list pytest.RECIPE_LIST = target_recipe_list pytest.RECIPE_OV_LIST = target_ov_recipe_list + pytest.TILE_RECIPE_LIST = tile_recipe_list @pytest.fixture(scope="session") diff --git a/tests/integration/test_tiling.py b/tests/integration/test_tiling.py index 1cd19be6874..574d8db14eb 100644 --- a/tests/integration/test_tiling.py +++ b/tests/integration/test_tiling.py @@ -4,17 +4,10 @@ from __future__ import annotations -from pathlib import Path -from unittest.mock import MagicMock - import numpy as np import pytest from datumaro import Dataset as DmDataset -from datumaro import Image -from datumaro.plugins.tiling.util import xywh_to_x1y1x2y2 from omegaconf import DictConfig, OmegaConf -from openvino.model_api.models import Model -from openvino.model_api.tilers import DetectionTiler, InstanceSegmentationTiler, Tiler from otx.core.config.data import ( DataModuleConfig, SubsetConfig, @@ -25,10 +18,7 @@ from otx.core.data.entity.detection import DetBatchDataEntity from otx.core.data.entity.tile import TileBatchDetDataEntity from otx.core.data.module import OTXDataModule -from otx.core.model.entity.detection import OVDetectionModel -from otx.core.model.entity.instance_segmentation import OVInstanceSegmentationModel from otx.core.types.task import OTXTaskType -from otx.engine import Engine class TestOTXTiling: @@ -94,32 +84,6 @@ def test_tile_transform(self): num_tile_cols = (width + w_stride - 1) // w_stride assert len(tiled_dataset) == (num_tile_rows * num_tile_cols * len(dataset)), "Incorrect number of tiles" - def test_tiler_consistency(self, mocker): - # Test that the tiler and tile transform are consistent - rng = np.random.default_rng() - rnd_tile_size = rng.integers(low=100, high=500) - rnd_tile_overlap = rng.random() - image_size = rng.integers(low=1000, high=5000) - np_image = np.zeros((image_size, image_size, 3), dtype=np.uint8) - dm_image = Image.from_numpy(np_image) - - mock_model = MagicMock(spec=Model) - mocker.patch("openvino.model_api.tilers.tiler.Tiler.__init__", return_value=None) - mocker.patch.multiple(Tiler, __abstractmethods__=set()) - - tiler = Tiler(model=mock_model) - tiler.tile_size = rnd_tile_size - tiler.tiles_overlap = rnd_tile_overlap - - mocker.patch("otx.core.data.dataset.tile.OTXTileTransform.__init__", return_value=None) - tile_transform = OTXTileTransform() - tile_transform._tile_size = (rnd_tile_size, rnd_tile_size) - tile_transform._overlap = (rnd_tile_overlap, rnd_tile_overlap) - - dm_rois = [xywh_to_x1y1x2y2(*roi) for roi in tile_transform._extract_rois(dm_image)] - # 0 index in tiler is the full image so we skip it - assert np.allclose(dm_rois, tiler._tile(np_image)[1:]) - def test_adaptive_tiling(self, fxt_det_data_config): # Enable tile adapter fxt_det_data_config.tile_config.enable_tiler = True @@ -183,60 +147,3 @@ def test_val_dataloader(self, fxt_det_data_config) -> None: def test_tile_merge(self): pytest.skip("Not implemented yet") - - def test_ov_det_tile_model( - self, - tmp_path: Path, - fxt_accelerator: str, - fxt_target_dataset_per_task: dict, - ): - tile_recipes = [recipe for recipe in pytest.RECIPE_LIST if "detection" in recipe and "tile" in recipe] - for tile_recipe in tile_recipes: - engine = Engine.from_config( - config_path=tile_recipe, - data_root=fxt_target_dataset_per_task[OTXTaskType.DETECTION.value.lower()], - work_dir=tmp_path / OTXTaskType.DETECTION, - device=fxt_accelerator, - ) - engine.train(max_epochs=1) - exported_model_path = engine.export() - assert exported_model_path.exists() - engine.test(exported_model_path, accelerator="cpu") - - ov_model = OVDetectionModel(model_name=exported_model_path, num_classes=3) - - assert isinstance(ov_model.model, DetectionTiler), "Model should be an instance of DetectionTiler" - assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size - assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap - - def test_ov_inst_tile_model( - self, - tmp_path: Path, - fxt_accelerator: str, - fxt_target_dataset_per_task: dict, - ): - # Test that tiler is setup correctly for instance segmentation - tile_recipes = [ - recipe for recipe in pytest.RECIPE_LIST if "instance_segmentation" in recipe and "tile" in recipe - ] - - for tile_recipe in tile_recipes: - engine = Engine.from_config( - config_path=tile_recipe, - data_root=fxt_target_dataset_per_task[OTXTaskType.INSTANCE_SEGMENTATION.value.lower()], - work_dir=tmp_path / OTXTaskType.INSTANCE_SEGMENTATION, - device=fxt_accelerator, - ) - engine.train(max_epochs=1) - exported_model_path = engine.export() - assert exported_model_path.exists() - engine.test(exported_model_path, accelerator="cpu") - - ov_model = OVInstanceSegmentationModel(model_name=exported_model_path, num_classes=3) - - assert isinstance( - ov_model.model, - InstanceSegmentationTiler, - ), "Model should be an instance of InstanceSegmentationTiler" - assert engine.datamodule.config.tile_config.tile_size[0] == ov_model.model.tile_size - assert engine.datamodule.config.tile_config.overlap == ov_model.model.tiles_overlap diff --git a/tests/unit/core/utils/test_tile.py b/tests/unit/core/utils/test_tile.py new file mode 100644 index 00000000000..b7b158dd3e2 --- /dev/null +++ b/tests/unit/core/utils/test_tile.py @@ -0,0 +1,58 @@ +# Copyright (C) 2024 Intel Corporation +# SPDX-License-Identifier: Apache-2.0 +# + +from __future__ import annotations + +from pathlib import Path +from unittest.mock import MagicMock + +import numpy as np +import pytest +from datumaro import Dataset as DmDataset +from datumaro import Image +from datumaro.plugins.tiling.util import xywh_to_x1y1x2y2 +from omegaconf import DictConfig, OmegaConf +from openvino.model_api.models import Model +from openvino.model_api.tilers import DetectionTiler, InstanceSegmentationTiler, Tiler +from otx.core.config.data import ( + DataModuleConfig, + SubsetConfig, + TileConfig, + VisualPromptingConfig, +) +from otx.core.data.dataset.tile import OTXTileTransform +from otx.core.data.entity.detection import DetBatchDataEntity +from otx.core.data.entity.tile import TileBatchDetDataEntity +from otx.core.data.module import OTXDataModule +from otx.core.model.entity.detection import OVDetectionModel +from otx.core.model.entity.instance_segmentation import OVInstanceSegmentationModel +from otx.core.types.task import OTXTaskType +from otx.engine import Engine + + +def test_tile_transform_consistency(mocker): + # Test that the tiler and tile transform are consistent + rng = np.random.default_rng() + rnd_tile_size = rng.integers(low=100, high=500) + rnd_tile_overlap = rng.random() + image_size = rng.integers(low=1000, high=5000) + np_image = np.zeros((image_size, image_size, 3), dtype=np.uint8) + dm_image = Image.from_numpy(np_image) + + mock_model = MagicMock(spec=Model) + mocker.patch("openvino.model_api.tilers.tiler.Tiler.__init__", return_value=None) + mocker.patch.multiple(Tiler, __abstractmethods__=set()) + + tiler = Tiler(model=mock_model) + tiler.tile_size = rnd_tile_size + tiler.tiles_overlap = rnd_tile_overlap + + mocker.patch("otx.core.data.dataset.tile.OTXTileTransform.__init__", return_value=None) + tile_transform = OTXTileTransform() + tile_transform._tile_size = (rnd_tile_size, rnd_tile_size) + tile_transform._overlap = (rnd_tile_overlap, rnd_tile_overlap) + + dm_rois = [xywh_to_x1y1x2y2(*roi) for roi in tile_transform._extract_rois(dm_image)] + # 0 index in tiler is the full image so we skip it + assert np.allclose(dm_rois, tiler._tile(np_image)[1:]) \ No newline at end of file From 166afc0d454a7be982d00016ad151ff8624df10b Mon Sep 17 00:00:00 2001 From: Eugene Liu Date: Mon, 4 Mar 2024 09:55:30 +0000 Subject: [PATCH 5/5] newline --- tests/unit/core/utils/test_tile.py | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/tests/unit/core/utils/test_tile.py b/tests/unit/core/utils/test_tile.py index b7b158dd3e2..a32a13cf91f 100644 --- a/tests/unit/core/utils/test_tile.py +++ b/tests/unit/core/utils/test_tile.py @@ -4,31 +4,14 @@ from __future__ import annotations -from pathlib import Path from unittest.mock import MagicMock import numpy as np -import pytest -from datumaro import Dataset as DmDataset from datumaro import Image from datumaro.plugins.tiling.util import xywh_to_x1y1x2y2 -from omegaconf import DictConfig, OmegaConf from openvino.model_api.models import Model -from openvino.model_api.tilers import DetectionTiler, InstanceSegmentationTiler, Tiler -from otx.core.config.data import ( - DataModuleConfig, - SubsetConfig, - TileConfig, - VisualPromptingConfig, -) +from openvino.model_api.tilers import Tiler from otx.core.data.dataset.tile import OTXTileTransform -from otx.core.data.entity.detection import DetBatchDataEntity -from otx.core.data.entity.tile import TileBatchDetDataEntity -from otx.core.data.module import OTXDataModule -from otx.core.model.entity.detection import OVDetectionModel -from otx.core.model.entity.instance_segmentation import OVInstanceSegmentationModel -from otx.core.types.task import OTXTaskType -from otx.engine import Engine def test_tile_transform_consistency(mocker): @@ -55,4 +38,4 @@ def test_tile_transform_consistency(mocker): dm_rois = [xywh_to_x1y1x2y2(*roi) for roi in tile_transform._extract_rois(dm_image)] # 0 index in tiler is the full image so we skip it - assert np.allclose(dm_rois, tiler._tile(np_image)[1:]) \ No newline at end of file + assert np.allclose(dm_rois, tiler._tile(np_image)[1:])