Delete deployment

deployment/Instance segmentation task/README.md

@@ -1,168 +0,0 @@
-# Exportable code
-
-Exportable code is a .zip archive that contains simple demo to get and visualize result of model inference.
-
-## Structure of generated zip
-
-- model
-  - `model.xml`
-  - `model.bin`
-  - `config.json`
-- python
-  - model_wrappers (Optional)
-    - `__init__.py`
-    - model_wrappers required to run demo
-  - `README.md`
-  - `LICENSE`
-  - `demo.py`
-  - `requirements.txt`
-
-> **NOTE**: Zip archive contains model_wrappers when [ModelAPI](https://github.com/openvinotoolkit/open_model_zoo/tree/master/demos/common/python/openvino/model_zoo/model_api) has no appropriate standard model wrapper for the model.
-
-## Prerequisites
-
-- [Python 3.8](https://www.python.org/downloads/)
-- [Git](https://git-scm.com/)
-
-## Install requirements to run demo
-
-1. Install [prerequisites](#prerequisites). You may also need to [install pip](https://pip.pypa.io/en/stable/installation/). For example, on Ubuntu execute the following command to get pip installed:
-
-   ```bash
-   sudo apt install python3-pip
-   ```
-
-1. Create clean virtual environment:
-
-   One of the possible ways for creating a virtual environment is to use `virtualenv`:
-
-   ```bash
-   python -m pip install virtualenv
-   python -m virtualenv <directory_for_environment>
-   ```
-
-   Before starting to work inside virtual environment, it should be activated:
-
-   On Linux and macOS:
-
-   ```bash
-   source <directory_for_environment>/bin/activate
-   ```
-
-   On Windows:
-
-   ```bash
-   .\<directory_for_environment>\Scripts\activate
-   ```
-
-   Please make sure that the environment contains [wheel](https://pypi.org/project/wheel/) by calling the following command:
-
-   ```bash
-   python -m pip install wheel
-   ```
-
-   > **NOTE**: On Linux and macOS, you may need to type `python3` instead of `python`.
-
-1. Install requirements in the environment:
-
-   ```bash
-   python -m pip install -r requirements.txt
-   ```
-
-1. Add `model_wrappers` package to PYTHONPATH:
-
-   On Linux and macOS:
-
-   ```bash
-   export PYTHONPATH=$PYTHONPATH:/path/to/model_wrappers
-   ```
-
-   On Windows:
-
-   ```bash
-   set PYTHONPATH=%PYTHONPATH%;/path/to/model_wrappers
-   ```
-
-## Usecase
-
-1. Running the `demo.py` application with the `-h` option yields the following usage message:
-
-   ```bash
-   usage: demo.py [-h] -i INPUT -m MODELS [MODELS ...] [-it {sync,async}] [-l] [--no_show] [-d {CPU,GPU}] [--output OUTPUT]
-
-   Options:
-   -h, --help            Show this help message and exit.
-   -i INPUT, --input INPUT
-                           Required. An input to process. The input must be a single image, a folder of images, video file or camera id.
-   -m MODELS [MODELS ...], --models MODELS [MODELS ...]
-                           Required. Path to directory with trained model and configuration file. If you provide several models you will start the task chain pipeline with the provided models in the order in
-                           which they were specified.
-   -it {sync,async}, --inference_type {sync,async}
-                           Optional. Type of inference for single model.
-   -l, --loop            Optional. Enable reading the input in a loop.
-   --no_show             Optional. Disables showing inference results on UI.
-   -d {CPU,GPU}, --device {CPU,GPU}
-                           Optional. Device to infer the model.
-   --output OUTPUT       Optional. Output path to save input data with predictions.
-   ```
-
-2. As a `model`, you can use path to model directory from generated zip. You can pass as `input` a single image, a folder of images, a video file, or a web camera id. So you can use the following command to do inference with a pre-trained model:
-
-   ```bash
-   python3 demo.py \
-   -i <path_to_video>/inputVideo.mp4 \
-   -m <path_to_model_directory>
-   ```
-
-   You can press `Q` to stop inference during demo running.
-
-   > **NOTE**: If you provide a single image as input, the demo processes and renders it quickly, then exits. To continuously
-   > visualize inference results on the screen, apply the `--loop` option, which enforces processing a single image in a loop.
-   > In this case, you can stop the demo by pressing `Q` button or killing the process in the terminal (`Ctrl+C` for Linux).
-   >
-   > **NOTE**: Default configuration contains info about pre- and post processing for inference and is guaranteed to be correct.
-   > Also you can change `config.json` that specifies the confidence threshold and color for each class visualization, but any
-   > changes should be made with caution.
-
-3. To save inferenced results with predictions on it, you can specify the folder path, using `--output`.
-   It works for images, videos, image folders and web cameras. To prevent issues, do not specify it together with a `--loop` parameter.
-
-   ```bash
-   python3 demo.py \
-      --input <path_to_image>/inputImage.jpg \
-      --models ../model \
-      --output resulted_images
-   ```
-
-4. To run a demo on a web camera, you need to know its ID.
-   You can check a list of camera devices by running this command line on Linux system:
-
-   ```bash
-   sudo apt-get install v4l-utils
-   v4l2-ctl --list-devices
-   ```
-
-   The output will look like this:
-
-   ```bash
-   Integrated Camera (usb-0000:00:1a.0-1.6):
-      /dev/video0
-   ```
-
-   After that, you can use this `/dev/video0` as a camera ID for `--input`.
-
-## Troubleshooting
-
-1. If you have access to the Internet through the proxy server only, please use pip with proxy call as demonstrated by command below:
-
-   ```bash
-   python -m pip install --proxy http://<usr_name>:<password>@<proxyserver_name>:<port#> <pkg_name>
-   ```
-
-1. If you use Anaconda environment, you should consider that OpenVINO has limited [Conda support](https://docs.openvino.ai/2021.4/openvino_docs_install_guides_installing_openvino_conda.html) for Python 3.6 and 3.7 versions only. But the demo package requires python 3.8. So please use other tools to create the environment (like `venv` or `virtualenv`) and use `pip` as a package manager.
-
-1. If you have problems when you try to use `pip install` command, please update pip version by following command:
-
-   ```bash
-   python -m pip install --upgrade pip
-   ```

deployment/Instance segmentation task/model.json

@@ -1,37 +0,0 @@
-{
-   "id": "6483248259c02bd70e8df1f4",
-   "name": "MaskRCNN-ResNet50 OpenVINO INT8",
-   "version": 1,
-   "creation_date": "2023-06-09T13:09:22.699000+00:00",
-   "model_format": "OpenVINO",
-   "precision": [
-      "INT8"
-   ],
-   "has_xai_head": false,
-   "target_device": "CPU",
-   "target_device_type": null,
-   "performance": {
-      "score": 0.9397590361445782
-   },
-   "size": 247759204,
-   "latency": 0,
-   "fps_throughput": 0,
-   "optimization_type": "NNCF",
-   "optimization_objectives": {},
-   "model_status": "SUCCESS",
-   "configurations": [
-      {
-         "name": "max_accuracy_drop",
-         "value": 0.01
-      },
-      {
-         "name": "filter_pruning",
-         "value": false
-      }
-   ],
-   "previous_revision_id": "6483248259c02bd70e8df1f5",
-   "previous_trained_revision_id": "648311e459c02bd70e8db073",
-   "optimization_methods": [
-      "QUANTIZATION"
-   ]
-}

deployment/Instance segmentation task/model/config.json

@@ -1,96 +0,0 @@
-{
-    "type_of_model": "OTX_MaskRCNN",
-    "converter_type": "INSTANCE_SEGMENTATION",
-    "model_parameters": {
-        "result_based_confidence_threshold": true,
-        "confidence_threshold": 0.8500000238418579,
-        "use_ellipse_shapes": false,
-        "resize_type": "fit_to_window",
-        "labels": {
-            "label_tree": {
-                "type": "tree",
-                "directed": true,
-                "nodes": [],
-                "edges": []
-            },
-            "label_groups": [
-                {
-                    "_id": "6483114c18fb8c1c529bd153",
-                    "name": "Instance segmentation labels",
-                    "label_ids": [
-                        "6483114c18fb8c1c529bd150"
-                    ],
-                    "relation_type": "EXCLUSIVE"
-                },
-                {
-                    "_id": "6483114c18fb8c1c529bd155",
-                    "name": "Empty",
-                    "label_ids": [
-                        "6483114c18fb8c1c529bd154"
-                    ],
-                    "relation_type": "EMPTY_LABEL"
-                }
-            ],
-            "all_labels": {
-                "6483114c18fb8c1c529bd150": {
-                    "_id": "6483114c18fb8c1c529bd150",
-                    "name": "egg",
-                    "color": {
-                        "red": 201,
-                        "green": 230,
-                        "blue": 73,
-                        "alpha": 255
-                    },
-                    "hotkey": "",
-                    "domain": "INSTANCE_SEGMENTATION",
-                    "creation_date": "2023-06-09T11:47:24.779000",
-                    "is_empty": false,
-                    "is_anomalous": false
-                },
-                "6483114c18fb8c1c529bd154": {
-                    "_id": "6483114c18fb8c1c529bd154",
-                    "name": "Empty",
-                    "color": {
-                        "red": 0,
-                        "green": 0,
-                        "blue": 0,
-                        "alpha": 255
-                    },
-                    "hotkey": "",
-                    "domain": "INSTANCE_SEGMENTATION",
-                    "creation_date": "2023-06-09T11:47:24.781000",
-                    "is_empty": true,
-                    "is_anomalous": false
-                }
-            }
-        }
-    },
-    "tiling_parameters": {
-        "visible_in_ui": true,
-        "type": "PARAMETER_GROUP",
-        "enable_tiling": false,
-        "enable_tile_classifier": false,
-        "enable_adaptive_params": true,
-        "tile_size": 400,
-        "tile_overlap": 0.2,
-        "tile_max_number": 1500,
-        "tile_ir_scale_factor": 2.0,
-        "tile_sampling_ratio": 1.0,
-        "object_tile_ratio": 0.03,
-        "header": "Tiling Parameters",
-        "description": "Tiling Parameters",
-        "_ParameterGroup__metadata_overrides": {},
-        "groups": [],
-        "parameters": [
-            "enable_adaptive_params",
-            "enable_tile_classifier",
-            "enable_tiling",
-            "object_tile_ratio",
-            "tile_ir_scale_factor",
-            "tile_max_number",
-            "tile_overlap",
-            "tile_sampling_ratio",
-            "tile_size"
-        ]
-    }
-}

deployment/Instance segmentation task/model/model.bin

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3128a90931c4b7b51ec0218fe952bac97d13b1763fc1f9cef1ecb620a22412e3
-size 56328440

deployment/Instance segmentation task/python/LICENSE

@@ -1,201 +0,0 @@
-Apache License
-Version 2.0, January 2004
-http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-"License" shall mean the terms and conditions for use, reproduction,
-and distribution as defined by Sections 1 through 9 of this document.
-
-"Licensor" shall mean the copyright owner or entity authorized by
-the copyright owner that is granting the License.
-
-"Legal Entity" shall mean the union of the acting entity and all
-other entities that control, are controlled by, or are under common
-control with that entity. For the purposes of this definition,
-"control" means (i) the power, direct or indirect, to cause the
-direction or management of such entity, whether by contract or
-otherwise, or (ii) ownership of fifty percent (50%) or more of the
-outstanding shares, or (iii) beneficial ownership of such entity.
-
-"You" (or "Your") shall mean an individual or Legal Entity
-exercising permissions granted by this License.
-
-"Source" form shall mean the preferred form for making modifications,
-including but not limited to software source code, documentation
-source, and configuration files.
-
-"Object" form shall mean any form resulting from mechanical
-transformation or translation of a Source form, including but
-not limited to compiled object code, generated documentation,
-and conversions to other media types.
-
-"Work" shall mean the work of authorship, whether in Source or
-Object form, made available under the License, as indicated by a
-copyright notice that is included in or attached to the work
-(an example is provided in the Appendix below).
-
-"Derivative Works" shall mean any work, whether in Source or Object
-form, that is based on (or derived from) the Work and for which the
-editorial revisions, annotations, elaborations, or other modifications
-represent, as a whole, an original work of authorship. For the purposes
-of this License, Derivative Works shall not include works that remain
-separable from, or merely link (or bind by name) to the interfaces of,
-the Work and Derivative Works thereof.
-
-"Contribution" shall mean any work of authorship, including
-the original version of the Work and any modifications or additions
-to that Work or Derivative Works thereof, that is intentionally
-submitted to Licensor for inclusion in the Work by the copyright owner
-or by an individual or Legal Entity authorized to submit on behalf of
-the copyright owner. For the purposes of this definition, "submitted"
-means any form of electronic, verbal, or written communication sent
-to the Licensor or its representatives, including but not limited to
-communication on electronic mailing lists, source code control systems,
-and issue tracking systems that are managed by, or on behalf of, the
-Licensor for the purpose of discussing and improving the Work, but
-excluding communication that is conspicuously marked or otherwise
-designated in writing by the copyright owner as "Not a Contribution."
-
-"Contributor" shall mean Licensor and any individual or Legal Entity
-on behalf of whom a Contribution has been received by Licensor and
-subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-this License, each Contributor hereby grants to You a perpetual,
-worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-copyright license to reproduce, prepare Derivative Works of,
-publicly display, publicly perform, sublicense, and distribute the
-Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-this License, each Contributor hereby grants to You a perpetual,
-worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-(except as stated in this section) patent license to make, have made,
-use, offer to sell, sell, import, and otherwise transfer the Work,
-where such license applies only to those patent claims licensable
-by such Contributor that are necessarily infringed by their
-Contribution(s) alone or by combination of their Contribution(s)
-with the Work to which such Contribution(s) was submitted. If You
-institute patent litigation against any entity (including a
-cross-claim or counterclaim in a lawsuit) alleging that the Work
-or a Contribution incorporated within the Work constitutes direct
-or contributory patent infringement, then any patent licenses
-granted to You under this License for that Work shall terminate
-as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-Work or Derivative Works thereof in any medium, with or without
-modifications, and in Source or Object form, provided that You
-meet the following conditions:
-
-(a) You must give any other recipients of the Work or
-Derivative Works a copy of this License; and
-
-(b) You must cause any modified files to carry prominent notices
-stating that You changed the files; and
-
-(c) You must retain, in the Source form of any Derivative Works
-that You distribute, all copyright, patent, trademark, and
-attribution notices from the Source form of the Work,
-excluding those notices that do not pertain to any part of
-the Derivative Works; and
-
-(d) If the Work includes a "NOTICE" text file as part of its
-distribution, then any Derivative Works that You distribute must
-include a readable copy of the attribution notices contained
-within such NOTICE file, excluding those notices that do not
-pertain to any part of the Derivative Works, in at least one
-of the following places: within a NOTICE text file distributed
-as part of the Derivative Works; within the Source form or
-documentation, if provided along with the Derivative Works; or,
-within a display generated by the Derivative Works, if and
-wherever such third-party notices normally appear. The contents
-of the NOTICE file are for informational purposes only and
-do not modify the License. You may add Your own attribution
-notices within Derivative Works that You distribute, alongside
-or as an addendum to the NOTICE text from the Work, provided
-that such additional attribution notices cannot be construed
-as modifying the License.
-
-You may add Your own copyright statement to Your modifications and
-may provide additional or different license terms and conditions
-for use, reproduction, or distribution of Your modifications, or
-for any such Derivative Works as a whole, provided Your use,
-reproduction, and distribution of the Work otherwise complies with
-the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-any Contribution intentionally submitted for inclusion in the Work
-by You to the Licensor shall be under the terms and conditions of
-this License, without any additional terms or conditions.
-Notwithstanding the above, nothing herein shall supersede or modify
-the terms of any separate license agreement you may have executed
-with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-names, trademarks, service marks, or product names of the Licensor,
-except as required for reasonable and customary use in describing the
-origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-agreed to in writing, Licensor provides the Work (and each
-Contributor provides its Contributions) on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-implied, including, without limitation, any warranties or conditions
-of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-PARTICULAR PURPOSE. You are solely responsible for determining the
-appropriateness of using or redistributing the Work and assume any
-risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-whether in tort (including negligence), contract, or otherwise,
-unless required by applicable law (such as deliberate and grossly
-negligent acts) or agreed to in writing, shall any Contributor be
-liable to You for damages, including any direct, indirect, special,
-incidental, or consequential damages of any character arising as a
-result of this License or out of the use or inability to use the
-Work (including but not limited to damages for loss of goodwill,
-work stoppage, computer failure or malfunction, or any and all
-other commercial damages or losses), even if such Contributor
-has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-the Work or Derivative Works thereof, You may choose to offer,
-and charge a fee for, acceptance of support, warranty, indemnity,
-or other liability obligations and/or rights consistent with this
-License. However, in accepting such obligations, You may act only
-on Your own behalf and on Your sole responsibility, not on behalf
-of any other Contributor, and only if You agree to indemnify,
-defend, and hold each Contributor harmless for any liability
-incurred by, or claims asserted against, such Contributor by reason
-of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS
-
-APPENDIX: How to apply the Apache License to your work.
-
-To apply the Apache License to your work, attach the following
-boilerplate notice, with the fields enclosed by brackets "[]"
-replaced with your own identifying information. (Don't include
-the brackets!)  The text should be enclosed in the appropriate
-comment syntax for the file format. We also recommend that a
-file or class name and description of purpose be included on the
-same "printed page" as the copyright notice for easier
-identification within third-party archives.
-
-Copyright (C) 2018-2021 Intel Corporation
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

deployment/Instance segmentation task/python/demo.py

@@ -1,132 +0,0 @@
-"""Demo based on ModelAPI."""
-# Copyright (C) 2021-2022 Intel Corporation
-# SPDX-License-Identifier: Apache-2.0
-#
-
-import os
-import sys
-from argparse import SUPPRESS, ArgumentParser
-from pathlib import Path
-
-os.environ["FEATURE_FLAGS_OTX_ACTION_TASKS"] = "1"
-
-# pylint: disable=no-name-in-module, import-error
-from otx.api.usecases.exportable_code.demo.demo_package import (
-    AsyncExecutor,
-    ChainExecutor,
-    ModelContainer,
-    SyncExecutor,
-    create_visualizer,
-)
-
-
-def build_argparser():
-    """Parses command line arguments."""
-    parser = ArgumentParser(add_help=False)
-    args = parser.add_argument_group("Options")
-    args.add_argument(
-        "-h",
-        "--help",
-        action="help",
-        default=SUPPRESS,
-        help="Show this help message and exit.",
-    )
-    args.add_argument(
-        "-i",
-        "--input",
-        required=True,
-        help="Required. An input to process. The input must be a single image, "
-        "a folder of images, video file or camera id.",
-    )
-    args.add_argument(
-        "-m",
-        "--models",
-        help="Required. Path to directory with trained model and configuration file. "
-        "If you provide several models you will start the task chain pipeline with "
-        "the provided models in the order in which they were specified.",
-        nargs="+",
-        required=True,
-        type=Path,
-    )
-    args.add_argument(
-        "-it",
-        "--inference_type",
-        help="Optional. Type of inference for single model.",
-        choices=["sync", "async"],
-        default="sync",
-        type=str,
-    )
-    args.add_argument(
-        "-l",
-        "--loop",
-        help="Optional. Enable reading the input in a loop.",
-        default=False,
-        action="store_true",
-    )
-    args.add_argument(
-        "--no_show",
-        help="Optional. Disables showing inference results on UI.",
-        default=False,
-        action="store_true",
-    )
-    args.add_argument(
-        "-d",
-        "--device",
-        help="Optional. Device to infer the model.",
-        choices=["CPU", "GPU"],
-        default="CPU",
-        type=str,
-    )
-    args.add_argument(
-        "--output",
-        default=None,
-        type=str,
-        help="Optional. Output path to save input data with predictions.",
-    )
-
-    return parser
-
-
-EXECUTORS = {
-    "sync": SyncExecutor,
-    "async": AsyncExecutor,
-    "chain": ChainExecutor,
-}
-
-
-def get_inferencer_class(type_inference, models):
-    """Return class for inference of models."""
-    if len(models) > 1:
-        type_inference = "chain"
-        print("You started the task chain pipeline with the provided models in the order in which they were specified")
-    return EXECUTORS[type_inference]
-
-
-def main():
-    """Main function that is used to run demo."""
-    args = build_argparser().parse_args()
-
-    if args.loop and args.output:
-        raise ValueError("--loop and --output cannot be both specified")
-
-    # create models
-    models = []
-    for model_dir in args.models:
-        model = ModelContainer(model_dir, device=args.device)
-        models.append(model)
-
-    inferencer = get_inferencer_class(args.inference_type, models)
-
-    # create visualizer
-    visualizer = create_visualizer(models[-1].task_type, no_show=args.no_show, output=args.output)
-
-    if len(models) == 1:
-        models = models[0]
-
-    # create inferencer and run
-    demo = inferencer(models, visualizer)
-    demo.run(args.input, args.loop and not args.no_show)
-
-
-if __name__ == "__main__":
-    sys.exit(main() or 0)

deployment/Instance segmentation task/python/model_wrappers/__init__.py

@@ -1,19 +0,0 @@
-"""Model Wrapper Initialization of OTX Detection."""
-
-# Copyright (C) 2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions
-# and limitations under the License.
-
-from .openvino_models import OTXMaskRCNNModel, OTXSSDModel
-
-__all__ = ["OTXMaskRCNNModel", "OTXSSDModel"]

deployment/Instance segmentation task/python/model_wrappers/openvino_models.py

@@ -1,194 +0,0 @@
-"""OTXMaskRCNNModel & OTXSSDModel of OTX Detection."""
-
-# Copyright (C) 2022 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions
-# and limitations under the License.
-
-from typing import Dict
-
-import numpy as np
-
-try:
-    from openvino.model_zoo.model_api.models.instance_segmentation import MaskRCNNModel
-    from openvino.model_zoo.model_api.models.ssd import SSD, find_layer_by_name
-    from openvino.model_zoo.model_api.models.utils import Detection
-except ImportError as e:
-    import warnings
-
-    warnings.warn(f"{e}: ModelAPI was not found.")
-
-
-class OTXMaskRCNNModel(MaskRCNNModel):
-    """OpenVINO model wrapper for OTX MaskRCNN model."""
-
-    __model__ = "OTX_MaskRCNN"
-
-    def __init__(self, model_adapter, configuration, preload=False):
-        super().__init__(model_adapter, configuration, preload)
-        self.resize_mask = True
-
-    def _check_io_number(self, number_of_inputs, number_of_outputs):
-        """Checks whether the number of model inputs/outputs is supported.
-
-        Args:
-            number_of_inputs (int, Tuple(int)): number of inputs supported by wrapper.
-              Use -1 to omit the check
-            number_of_outputs (int, Tuple(int)): number of outputs supported by wrapper.
-              Use -1 to omit the check
-
-        Raises:
-            WrapperError: if the model has unsupported number of inputs/outputs
-        """
-        super()._check_io_number(number_of_inputs, -1)
-
-    def _get_outputs(self):
-        output_match_dict = {}
-        output_names = ["boxes", "labels", "masks", "feature_vector", "saliency_map"]
-        for output_name in output_names:
-            for node_name, node_meta in self.outputs.items():
-                if output_name in node_meta.names:
-                    output_match_dict[output_name] = node_name
-                    break
-        return output_match_dict
-
-    def postprocess(self, outputs, meta):
-        """Post process function for OTX MaskRCNN model."""
-
-        # pylint: disable-msg=too-many-locals
-        # FIXME: here, batch dim of IR must be 1
-        boxes = outputs[self.output_blob_name["boxes"]]
-        if boxes.shape[0] == 1:
-            boxes = boxes.squeeze(0)
-        assert boxes.ndim == 2
-        masks = outputs[self.output_blob_name["masks"]]
-        if masks.shape[0] == 1:
-            masks = masks.squeeze(0)
-        assert masks.ndim == 3
-        classes = outputs[self.output_blob_name["labels"]].astype(np.uint32)
-        if classes.shape[0] == 1:
-            classes = classes.squeeze(0)
-        assert classes.ndim == 1
-        if self.is_segmentoly:
-            scores = outputs[self.output_blob_name["scores"]]
-        else:
-            scores = boxes[:, 4]
-            boxes = boxes[:, :4]
-            classes += 1
-
-        # Filter out detections with low confidence.
-        detections_filter = scores > self.confidence_threshold  # pylint: disable=no-member
-        scores = scores[detections_filter]
-        boxes = boxes[detections_filter]
-        masks = masks[detections_filter]
-        classes = classes[detections_filter]
-
-        scale_x = meta["resized_shape"][1] / meta["original_shape"][1]
-        scale_y = meta["resized_shape"][0] / meta["original_shape"][0]
-        boxes[:, 0::2] /= scale_x
-        boxes[:, 1::2] /= scale_y
-
-        resized_masks = []
-        for box, cls, raw_mask in zip(boxes, classes, masks):
-            raw_cls_mask = raw_mask[cls, ...] if self.is_segmentoly else raw_mask
-            if self.resize_mask:
-                resized_masks.append(self._segm_postprocess(box, raw_cls_mask, *meta["original_shape"][:-1]))
-            else:
-                resized_masks.append(raw_cls_mask)
-
-        return scores, classes, boxes, resized_masks
-
-    def segm_postprocess(self, *args, **kwargs):
-        """Post-process for segmentation masks."""
-        return self._segm_postprocess(*args, **kwargs)
-
-    def disable_mask_resizing(self):
-        """Disable mask resizing.
-
-        There is no need to resize mask in tile as it will be processed at the end.
-        """
-        self.resize_mask = False
-
-
-class OTXSSDModel(SSD):
-    """OpenVINO model wrapper for OTX SSD model."""
-
-    __model__ = "OTX_SSD"
-
-    def __init__(self, model_adapter, configuration=None, preload=False):
-        # pylint: disable-next=bad-super-call
-        super(SSD, self).__init__(model_adapter, configuration, preload)
-        self.image_info_blob_name = self.image_info_blob_names[0] if len(self.image_info_blob_names) == 1 else None
-        self.output_parser = BatchBoxesLabelsParser(
-            self.outputs,
-            self.inputs[self.image_blob_name].shape[2:][::-1],
-        )
-
-    def _get_outputs(self) -> Dict:
-        """Match the output names with graph node index."""
-        output_match_dict = {}
-        output_names = ["boxes", "labels", "feature_vector", "saliency_map"]
-        for output_name in output_names:
-            for node_name, node_meta in self.outputs.items():
-                if output_name in node_meta.names:
-                    output_match_dict[output_name] = node_name
-                    break
-        return output_match_dict
-
-
-class BatchBoxesLabelsParser:
-    """Batched output parser."""
-
-    def __init__(self, layers, input_size, labels_layer="labels", default_label=0):
-        try:
-            self.labels_layer = find_layer_by_name(labels_layer, layers)
-        except ValueError:
-            self.labels_layer = None
-            self.default_label = default_label
-
-        try:
-            self.bboxes_layer = self.find_layer_bboxes_output(layers)
-        except ValueError:
-            self.bboxes_layer = find_layer_by_name("boxes", layers)
-
-        self.input_size = input_size
-
-    @staticmethod
-    def find_layer_bboxes_output(layers):
-        """find_layer_bboxes_output."""
-        filter_outputs = [name for name, data in layers.items() if len(data.shape) == 3 and data.shape[-1] == 5]
-        if not filter_outputs:
-            raise ValueError("Suitable output with bounding boxes is not found")
-        if len(filter_outputs) > 1:
-            raise ValueError("More than 1 candidate for output with bounding boxes.")
-        return filter_outputs[0]
-
-    def __call__(self, outputs):
-        """Parse bboxes."""
-        # FIXME: here, batch dim of IR must be 1
-        bboxes = outputs[self.bboxes_layer]
-        if bboxes.shape[0] == 1:
-            bboxes = bboxes.squeeze(0)
-        assert bboxes.ndim == 2
-        scores = bboxes[:, 4]
-        bboxes = bboxes[:, :4]
-        bboxes[:, 0::2] /= self.input_size[0]
-        bboxes[:, 1::2] /= self.input_size[1]
-        if self.labels_layer:
-            labels = outputs[self.labels_layer]
-        else:
-            labels = np.full(len(bboxes), self.default_label, dtype=bboxes.dtype)
-        if labels.shape[0] == 1:
-            labels = labels.squeeze(0)
-
-        detections = [Detection(*bbox, score, label) for label, score, bbox in zip(labels, scores, bboxes)]
-        return detections

deployment/Instance segmentation task/python/requirements.txt

@@ -1,4 +0,0 @@
-openvino==2022.3.0
-openmodelzoo-modelapi==2022.3.0
-otx=1.2.3.3
-numpy>=1.21.0,<=1.23.5  # np.bool was removed in 1.24.0 which was used in openvino runtime

deployment/project.json

@@ -1,67 +0,0 @@
-{
-   "id": "6483114c18fb8c1c529bd149",
-   "name": "eggs!",
-   "creation_time": "2023-06-09T11:47:24.780000+00:00",
-   "creator_id": "[email protected]",
-   "pipeline": {
-      "tasks": [
-         {
-            "id": "6483114c18fb8c1c529bd14a",
-            "title": "Dataset",
-            "task_type": "dataset"
-         },
-         {
-            "id": "6483114c18fb8c1c529bd14d",
-            "title": "Instance segmentation task",
-            "task_type": "instance_segmentation",
-            "labels": [
-               {
-                  "id": "6483114c18fb8c1c529bd150",
-                  "name": "egg",
-                  "is_anomalous": false,
-                  "color": "#c9e649ff",
-                  "hotkey": "",
-                  "is_empty": false,
-                  "group": "Instance segmentation labels",
-                  "parent_id": null
-               },
-               {
-                  "id": "6483114c18fb8c1c529bd154",
-                  "name": "Empty",
-                  "is_anomalous": false,
-                  "color": "#000000ff",
-                  "hotkey": "",
-                  "is_empty": true,
-                  "group": "Empty",
-                  "parent_id": null
-               }
-            ],
-            "label_schema_id": "6483114c18fb8c1c529bd156"
-         }
-      ],
-      "connections": [
-         {
-            "from": "6483114c18fb8c1c529bd14a",
-            "to": "6483114c18fb8c1c529bd14d"
-         }
-      ]
-   },
-   "datasets": [
-      {
-         "id": "6483114c18fb8c1c529bd151",
-         "name": "Dataset",
-         "use_for_training": true,
-         "creation_time": "2023-06-09T11:47:24.780000+00:00"
-      },
-      {
-         "id": "64898e9c68d5ade57e325981",
-         "name": "Testing set 1",
-         "use_for_training": false,
-         "creation_time": "2023-06-14T09:55:40.186000+00:00"
-      }
-   ],
-   "thumbnail": "/api/v1/workspaces/6487656fb7efbf83c9b9ec35/projects/6483114c18fb8c1c529bd149/thumbnail",
-   "performance": {
-      "score": 0.9702380952380952
-   }
-}