Enable otx deploy

Author: sungchul2

src/otx/algorithms/visual_prompting/tasks/openvino.py

@@ -14,19 +14,24 @@
 # See the License for the specific language governing permissions
 # and limitations under the License.
 
+import io
+import json
 import os
 import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
+from zipfile import ZipFile
 
 import attr
 import numpy as np
 from openvino.model_zoo.model_api.adapters import OpenvinoAdapter, create_core
 from openvino.model_zoo.model_api.models import Model
 
-import otx.algorithms.visual_prompting.adapters.openvino.model_wrappers  # noqa: F401
 from otx.algorithms.common.utils.logger import get_logger
 from otx.algorithms.common.utils.utils import get_default_async_reqs_num
+from otx.algorithms.visual_prompting.adapters.openvino import (  # noqa: F401
+    model_wrappers,
+)
 from otx.algorithms.visual_prompting.adapters.pytorch_lightning.datasets.dataset import (
     OTXVisualPromptingDataset,
     get_transform,
@@ -45,7 +50,9 @@
 from otx.api.entities.optimization_parameters import OptimizationParameters
 from otx.api.entities.resultset import ResultSetEntity
 from otx.api.entities.task_environment import TaskEnvironment
+from otx.api.serialization.label_mapper import LabelSchemaMapper
 from otx.api.usecases.evaluation.metrics_helper import MetricsHelper
+from otx.api.usecases.exportable_code import demo
 from otx.api.usecases.exportable_code.inference import BaseInferencer
 from otx.api.usecases.exportable_code.prediction_to_annotation_converter import (
     VisualPromptingToAnnotationConverter,
@@ -260,7 +267,60 @@ def evaluate(self, output_resultset: ResultSetEntity, evaluation_metric: Optiona
 
     def deploy(self, output_model: ModelEntity) -> None:
         """Deploy function of OpenVINOVisualPromptingTask."""
-        print("deploy start!")
+        logger.info("Deploying the model")
+        if self.model is None:
+            raise RuntimeError("deploy failed, model is None")
+
+        work_dir = os.path.dirname(demo.__file__)
+        parameters = {}
+        parameters["converter_type"] = f"{self.task_type}"
+        parameters["model_parameters"] = self.inferencer.configuration  # type: ignore
+        parameters["model_parameters"]["labels"] = LabelSchemaMapper.forward(self.task_environment.label_schema)  # type: ignore # noqa: E501
+
+        zip_buffer = io.BytesIO()
+        with ZipFile(zip_buffer, "w") as arch:
+            # model files
+            arch.writestr(
+                os.path.join("model", "visual_prompting_image_encoder.xml"),
+                self.model.get_data("visual_prompting_image_encoder.xml"),
+            )
+            arch.writestr(
+                os.path.join("model", "visual_prompting_image_encoder.bin"),
+                self.model.get_data("visual_prompting_image_encoder.bin"),
+            )
+            arch.writestr(
+                os.path.join("model", "visual_prompting_decoder.xml"),
+                self.model.get_data("visual_prompting_decoder.xml"),
+            )
+            arch.writestr(
+                os.path.join("model", "visual_prompting_decoder.bin"),
+                self.model.get_data("visual_prompting_decoder.bin"),
+            )
+            arch.writestr(
+                os.path.join("model", "config.json"),
+                json.dumps(parameters, ensure_ascii=False, indent=4),
+            )
+            # model_wrappers files
+            for root, _, files in os.walk(os.path.dirname(model_wrappers.__file__)):
+                if "__pycache__" in root:
+                    continue
+                for file in files:
+                    file_path = os.path.join(root, file)
+                    arch.write(
+                        file_path,
+                        os.path.join(
+                            "python",
+                            "model_wrappers",
+                            file_path.split("model_wrappers/")[0],
+                        ),
+                    )
+            # other python files
+            arch.write(os.path.join(work_dir, "requirements.txt"), os.path.join("python", "requirements.txt"))
+            arch.write(os.path.join(work_dir, "LICENSE"), os.path.join("python", "LICENSE"))
+            arch.write(os.path.join(work_dir, "demo.py"), os.path.join("python", "demo.py"))
+            arch.write(os.path.join(work_dir, "README.md"), os.path.join(".", "README.md"))
+        output_model.exportable_code = zip_buffer.getvalue()
+        logger.info("Deploying completed")
 
     def optimize(
         self,

tests/unit/algorithms/visual_prompting/tasks/test_openvino.py

@@ -4,40 +4,43 @@
 # SPDX-License-Identifier: Apache-2.0
 #
 
+from copy import deepcopy
+
 import numpy as np
-import torch
 import pytest
-from otx.api.entities.dataset_item import DatasetItemEntity
-from otx.algorithms.visual_prompting.adapters.pytorch_lightning.datasets.dataset import OTXVisualPromptingDataset
+import torch
 from openvino.model_zoo.model_api.models import Model
+
+from otx.algorithms.visual_prompting.adapters.pytorch_lightning.datasets.dataset import (
+    OTXVisualPromptingDataset,
+)
 from otx.algorithms.visual_prompting.configs.base import VisualPromptingBaseConfig
 from otx.algorithms.visual_prompting.tasks.openvino import (
     OpenVINOVisualPromptingInferencer,
     OpenVINOVisualPromptingTask,
 )
-from otx.api.entities.annotation import (
-    Annotation,
-    AnnotationSceneEntity,
-    AnnotationSceneKind,
-)
+from otx.api.configuration.configurable_parameters import ConfigurableParameters
+from otx.api.entities.annotation import Annotation
+from otx.api.entities.dataset_item import DatasetItemEntity
 from otx.api.entities.datasets import DatasetEntity
 from otx.api.entities.inference_parameters import InferenceParameters
 from otx.api.entities.label import LabelEntity
+from otx.api.entities.label_schema import LabelSchemaEntity
 from otx.api.entities.metrics import Performance, ScoreMetric
+from otx.api.entities.model import ModelConfiguration, ModelEntity
 from otx.api.entities.resultset import ResultSetEntity
 from otx.api.entities.scored_label import ScoredLabel
 from otx.api.entities.shapes.polygon import Point, Polygon
 from otx.api.usecases.evaluation.metrics_helper import MetricsHelper
+from otx.api.usecases.exportable_code.prediction_to_annotation_converter import (
+    VisualPromptingToAnnotationConverter,
+)
 from otx.api.utils.shape_factory import ShapeFactory
-
 from tests.test_suite.e2e_test_system import e2e_pytest_unit
 from tests.unit.algorithms.visual_prompting.test_helpers import (
     generate_visual_prompting_dataset,
     init_environment,
 )
-from otx.api.usecases.exportable_code.prediction_to_annotation_converter import (
-    VisualPromptingToAnnotationConverter,
-)
 
 
 class TestOpenVINOVisualPromptingInferencer:
@@ -159,8 +162,16 @@ def test_forward_decoder(self):
 
 
 class TestOpenVINOVisualPromptingTask:
+    @pytest.fixture
+    def otx_model(self):
+        model_configuration = ModelConfiguration(
+            configurable_parameters=ConfigurableParameters(header="header", description="description"),
+            label_schema=LabelSchemaEntity(),
+        )
+        return ModelEntity(train_dataset=DatasetEntity(), configuration=model_configuration)
+
     @pytest.fixture(autouse=True)
-    def setup(self, mocker):
+    def setup(self, mocker, otx_model):
         """Load the OpenVINOVisualPromptingTask."""
         mocker.patch("otx.algorithms.visual_prompting.tasks.openvino.OpenvinoAdapter")
         mocker.patch.object(Model, "create_model")
@@ -174,7 +185,8 @@ def setup(self, mocker):
             {"image_encoder": "", "decoder": ""},
         )
 
-        self.task_environment.model = mocker.patch("otx.api.entities.model.ModelEntity")
+        # self.task_environment.model = mocker.patch("otx.api.entities.model.ModelEntity")
+        self.task_environment.model = otx_model
         mocker.patch.object(OpenVINOVisualPromptingTask, "load_inferencer", return_value=visual_prompting_ov_inferencer)
         self.visual_prompting_ov_task = OpenVINOVisualPromptingTask(task_environment=self.task_environment)
 
@@ -220,3 +232,14 @@ def test_evaluate(self, mocker):
         self.visual_prompting_ov_task.evaluate(result_set)
 
         assert result_set.performance.score.value == 0.1
+
+    @e2e_pytest_unit
+    def test_deploy(self):
+        output_model = deepcopy(self.task_environment.model)
+        self.visual_prompting_ov_task.model.set_data("visual_prompting_image_encoder.bin", b"image_encoder_bin")
+        self.visual_prompting_ov_task.model.set_data("visual_prompting_image_encoder.xml", b"image_encoder_xml")
+        self.visual_prompting_ov_task.model.set_data("visual_prompting_decoder.bin", b"decoder_bin")
+        self.visual_prompting_ov_task.model.set_data("visual_prompting_decoder.xml", b"deocder_xml")
+        self.visual_prompting_ov_task.deploy(output_model)
+
+        assert output_model.exportable_code is not None