Upload 29 files

.gitattributes

@@ -36,3 +36,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 eggsample1.png filter=lfs diff=lfs merge=lfs -text
 eggsample2.png filter=lfs diff=lfs merge=lfs -text
 deployment2/sample_image.jpg filter=lfs diff=lfs merge=lfs -text
+deployments/sample_image.jpg filter=lfs diff=lfs merge=lfs -text

deployments/LICENSE

@@ -0,0 +1,201 @@
+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.

deployments/README.md

@@ -0,0 +1,227 @@
+# Code deployment
+## Table of contents
+- [Introduction](#introduction)
+- [Prerequisites](#prerequisites)
+- [Installation](#Installation)
+- [Usage](#usage)
+- [Troubleshooting](#troubleshooting)
+- [Package contents](#package-contents)
+
+
+## Introduction
+
+This code deployment .zip archive contains:
+
+1. Inference model(s) for your Intel® Geti™ project.
+
+2. A sample image or video frame, exported from your project.   
+
+3. A very simple code example to get and visualize the result of inference for your 
+   project, on the sample image.
+   
+4. Jupyter notebooks with instructions and code for running inference for your project, 
+   either locally or via the OpenVINO Model Server (OVMS).
+
+The deployment holds one model for each task in your project, so if for example 
+you created a deployment for a `Detection -> Classification` project, it will consist of
+both a detection, and a classification model. The Intel® Geti™ SDK is used to run 
+inference for all models in the project's task chain.
+
+This README describes the steps required to get the code sample up and running on your 
+machine.
+
+## Prerequisites
+
+- [Python 3.9, 3.10 or 3.11](https://www.python.org/downloads/)
+- [*Optional, only for OVMS notebook*] [Docker](https://docs.docker.com/get-docker/) 
+
+## Installation
+
+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 install Python and pip:
+
+   ```
+   sudo apt install python3-dev python3-pip
+   ```
+   If you already have installed pip before, make sure it is up to date by doing:
+
+   ```
+   pip install --upgrade pip
+   ```
+
+2. Create a clean virtual environment: <a name="virtual-env-creation"></a>
+
+   One of the possible ways for creating a virtual environment is to use `virtualenv`:
+
+   ```
+   python -m pip install virtualenv
+   python -m virtualenv <directory_for_environment>
+   ```
+
+   Before starting to work inside the virtual environment, it should be activated:
+
+   On Linux and macOS:
+
+   ```
+   source <directory_for_environment>/bin/activate
+   ```
+
+   On Windows:
+
+   ```
+   .\<directory_for_environment>\Scripts\activate
+   ```
+
+   Please make sure that the environment contains 
+   [wheel](https://pypi.org/project/wheel/) by calling the following command:
+
+   ```
+   python -m pip install wheel
+   ```
+
+   > **NOTE**: On Linux and macOS, you may need to type `python3` instead of `python`.
+
+3. In your terminal, navigate to the `example_code` directory in the code deployment 
+   package.
+
+4. Install requirements in the environment:
+
+   ```
+   python -m pip install -r requirements.txt
+   ```
+
+5. (Optional) Install the requirements for running the `demo_notebook.ipynb` or 
+   `demo_ovms.ipynb` Juypter notebooks:
+
+   ```
+   python -m pip install -r requirements-notebook.txt
+   ```
+   
+## Usage
+### Local inference
+Both `demo.py` script and the `demo_notebook.ipynb` notebook contain a code sample for:
+
+1. Loading the code deployment (and the models it contains) into memory.
+
+2. Loading the `sample_image.jpg`, which is a random image taken from the project you 
+   deployed. 
+
+3. Running inference on the sample image.
+
+4. Visualizing the inference results.
+
+### Inference with OpenVINO Model Server
+The additional demo notebook `demo_ovms.ipynb` shows how to set up and run an OpenVINO 
+Model Server for your deployment, and make inference requests to it. The notebook 
+contains instructions and code to:
+
+1. Generate a configuration file for OVMS.
+
+2. Launch an OVMS docker container with the proper configuration.
+
+3. Load the image `sample_image.jpg`, as an example image to run inference on.
+
+4. Make an inference request to OVMS.
+
+5. Visualize the inference results.
+
+### Running the demo script
+
+In your terminal:
+
+1. Make sure the virtual environment created [above](#virtual-env-creation) is activated.
+
+2. Make sure you are in the `example_code` directory in your terminal.
+
+3. Run the demo using:
+  
+   ```
+   python demo.py
+   ```
+
+The script will run inference on the `sample_image.jpg`. A window will pop up that 
+displays the image, and the results of the inference visualized on top of it.
+
+### Running the demo notebooks
+
+In your terminal:
+
+1. Make sure the virtual environment created [above](#virtual-env-creation) is activated.
+
+2. Make sure you are in the `example_code` directory in your terminal.
+
+3. Start JupyterLab using:
+   
+   ```
+   jupyter lab
+   ```
+   
+4. This should launch your web browser and take you to the main page of JupyterLab.
+
+Inside JuypterLab:
+
+5. In the sidebar of the JupyterLab interface, double-click on `demo_notebook.ipynb` or
+   `demo_ovms.ipynb` to open one of the notebooks.
+   
+6. Execute the notebook cell by cell to view the inference results. 
+
+
+> **NOTE** The `demo_notebook.ipynb` is a great way to explore the `AnnotationScene` 
+> object that is returned by the inference. The demo code only has very basic 
+> visualization functionality, which may not be sufficient for all use case. For 
+> example if your project contains many labels, it may not be able to visualize the 
+> results very well. In that case, you should build your own visualization logic 
+> based on the `AnnotationScene` returned by the `deployment.infer()` method.
+
+## Troubleshooting
+
+1. If you have access to the Internet through a proxy server only, please use pip 
+   with a proxy call as demonstrated by the command below:
+
+   ```
+   python -m pip install --proxy http://<usr_name>:<password>@<proxyserver_name>:<port#> <pkg_name>
+   ```
+
+2. If you use Anaconda as environment manager, please consider that OpenVINO has 
+   limited [Conda support](https://docs.openvino.ai/2021.4/openvino_docs_install_guides_installing_openvino_conda.html). 
+   It is still possible to use `conda` to create and activate your python environment, 
+   but in that case please use only `pip` (rather than `conda`) as a package manager 
+   for installing packages in your environment.
+
+3. If you have problems when you try to use the `pip install` command, please update 
+   pip version as per the following command:
+   ```
+   python -m pip install --upgrade pip
+   ```
+
+## Package contents
+
+The code deployment files are structured as follows:
+
+- deployment
+    - `project.json`
+    - "<title of task 1>"  
+        - model
+          - `model.xml`
+          - `model.bin`
+          - `config.json`
+        - python
+          - model_wrappers
+            - `__init__.py`
+            - model_wrappers required to run demo
+          - `README.md`
+          - `LICENSE`
+          - `demo.py`
+          - `requirements.txt`
+    - "<title of task 2>" (Optional)
+        - ...
+- example_code
+    - `demo.py`
+    - `demo_notebook.ipynb`
+    - `demo_ovms.ipynb`  
+    - `README.md`
+    - `requirements.txt`
+    - `requirements-notebook.txt`
+- `sample_image.jpg`
+- `LICENSE`

deployments/deployment/Instance segmentation task/LICENSE

@@ -0,0 +1,201 @@
+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.

deployments/deployment/Instance segmentation task/README.md

@@ -0,0 +1,164 @@
+# Exportable code
+
+Exportable code is a .zip archive that contains simple demo to get and visualize result of model inference.
+
+## Structure of generated zip
+
+- `README.md`
+- `LICENSE`
+- model
+  - `model.xml`
+  - `model.bin`
+  - `config.json`
+- python
+  - demo_package
+    - `__init__.py`
+    - executors
+      - `__init__.py`
+      - `asynchronous.py`
+      - `synchronous.py`
+    - inference
+      - `__init__.py`
+      - `inference.py`
+    - streamer
+      - `__init__.py`
+      - `streamer.py`
+    - visualizers
+      - `__init__.py`
+      - `visualizer.py`
+      - `vis_utils.py`
+  - `demo.py`
+  - `requirements.txt`
+  - `setup.py`
+
+## Prerequisites
+
+- [Python 3.10](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
+   cd python
+   python setup.py install
+   ```
+
+## Usecase
+
+1. Running the `demo.py` application with the `-h` option yields the following usage message:
+
+   ```bash
+   usage: demo.py [-h] -i INPUT -m MODEL [MODEL ...] [-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 MODEL [MODEL ...], --model MODELS [MODELS ...]
+                           Optional. Path to directory with trained model and configuration file. Default value points to deployed model folder '../model'.
+   -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` parameter the default value `../model` will be used. Or you can specify the other path to the 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
+   ```
+
+   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
+   ```

deployments/deployment/Instance segmentation task/model.json

@@ -0,0 +1,26 @@
+{
+   "id": "6807ecb527f5406c0158ae5b",
+   "name": "RTMDet_tiny OpenVINO FP16",
+   "version": 1,
+   "creation_date": "2025-04-22T19:23:33.177000+00:00",
+   "model_format": "OpenVINO",
+   "precision": [
+      "FP16"
+   ],
+   "has_xai_head": false,
+   "target_device": "CPU",
+   "target_device_type": null,
+   "performance": {
+      "score": 0.9520755876647748
+   },
+   "size": 12618721,
+   "latency": 0,
+   "fps_throughput": 0,
+   "optimization_type": "MO",
+   "optimization_objectives": {},
+   "model_status": "SUCCESS",
+   "configurations": [],
+   "previous_revision_id": "6807ecb527f5406c0158ae58",
+   "previous_trained_revision_id": "6807ecb527f5406c0158ae58",
+   "optimization_methods": []
+}

deployments/deployment/Instance segmentation task/model/config.json

@@ -0,0 +1,8 @@
+{
+    "task_type": "instance_segmentation",
+    "model_type": "MaskRCNN",
+    "model_parameters": {
+        "labels": "otx_empty_lbl egg Empty",
+        "labels_ids": "None 6483114c18fb8c1c529bd150 6483114c18fb8c1c529bd154"
+    }
+}

deployments/deployment/Instance segmentation task/model/model.bin

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

deployments/deployment/Instance segmentation task/python/demo.py

@@ -0,0 +1,107 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Demo based on ModelAPI."""
+
+import sys
+from argparse import SUPPRESS, ArgumentParser
+from pathlib import Path
+
+from demo_package import AsyncExecutor, ModelWrapper, SyncExecutor, create_visualizer
+
+
+def build_argparser() -> ArgumentParser:
+    """Returns an ArgumentParser for parsing 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",
+        "--model",
+        help="Optional. Path to directory with trained model and configuration file. "
+        "Default value points to deployed model folder '../model'.",
+        default=Path("../model"),
+        type=Path,
+    )
+    args.add_argument(
+        "-it",
+        "--inference_type",
+        help="Optional. Type of inference for single model.",
+        choices=["sync", "async"],
+        default="async",
+        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="./outputs/model_visualization",
+        type=str,
+        help="Optional. Output path to save input data with predictions.",
+    )
+
+    return parser
+
+
+EXECUTORS = {
+    "sync": SyncExecutor,
+    "async": AsyncExecutor,
+}
+
+
+def main() -> int:
+    """Main function that is used to run demo."""
+    args = build_argparser().parse_args()
+
+    if args.loop and args.output:
+        msg = "--loop and --output cannot be both specified"
+        raise ValueError(msg)
+
+    # create models
+    model = ModelWrapper(args.model, device=args.device)
+    inferencer = EXECUTORS[args.inference_type]
+
+    # create visualizer
+    visualizer = create_visualizer(model.task_type, model.labels, no_show=args.no_show, output=args.output)
+
+    # create inferencer and run
+    demo = inferencer(model, visualizer)
+    demo.run(args.input, args.loop and not args.no_show)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

deployments/deployment/Instance segmentation task/python/demo_package/__init__.py

@@ -0,0 +1,27 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Initialization of demo package."""
+
+from .executors import AsyncExecutor, SyncExecutor
+from .model_wrapper import ModelWrapper
+from .utils import create_visualizer
+from .visualizers import (
+    BaseVisualizer,
+    ClassificationVisualizer,
+    InstanceSegmentationVisualizer,
+    ObjectDetectionVisualizer,
+    SemanticSegmentationVisualizer,
+)
+
+__all__ = [
+    "SyncExecutor",
+    "AsyncExecutor",
+    "create_visualizer",
+    "ModelWrapper",
+    "BaseVisualizer",
+    "ClassificationVisualizer",
+    "SemanticSegmentationVisualizer",
+    "InstanceSegmentationVisualizer",
+    "ObjectDetectionVisualizer",
+]

deployments/deployment/Instance segmentation task/python/demo_package/executors/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Initialization of executors."""
+
+from .asynchronous import AsyncExecutor
+from .synchronous import SyncExecutor
+
+__all__ = [
+    "SyncExecutor",
+    "AsyncExecutor",
+]

deployments/deployment/Instance segmentation task/python/demo_package/executors/asynchronous.py

@@ -0,0 +1,79 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Async executor based on ModelAPI."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+from model_api.pipelines import AsyncPipeline
+
+if TYPE_CHECKING:
+    import numpy as np
+    from demo_package.model_wrapper import ModelWrapper
+
+
+from demo_package.streamer import get_streamer
+from demo_package.visualizers import BaseVisualizer, dump_frames
+
+
+class AsyncExecutor:
+    """Async inferencer.
+
+    Args:
+        model: model for inference
+        visualizer: visualizer of inference results
+    """
+
+    def __init__(self, model: ModelWrapper, visualizer: BaseVisualizer) -> None:
+        self.model = model
+        self.visualizer = visualizer
+        self.async_pipeline = AsyncPipeline(self.model.core_model)
+
+    def run(self, input_stream: int | str, loop: bool = False) -> None:
+        """Async inference for input stream (image, video stream, camera)."""
+        streamer = get_streamer(input_stream, loop)
+        next_frame_id = 0
+        next_frame_id_to_show = 0
+        stop_visualization = False
+        saved_frames = []
+
+        for frame in streamer:
+            results = self.async_pipeline.get_result(next_frame_id_to_show)
+            while results:
+                start_time = time.perf_counter()
+                output = self.render_result(results)
+                next_frame_id_to_show += 1
+                self.visualizer.show(output)
+                if self.visualizer.output:
+                    saved_frames.append(output)
+                stop_visualization = self.visualizer.is_quit()
+                # visualize video not faster than the original FPS
+                self.visualizer.video_delay(time.perf_counter() - start_time, streamer)
+                results = self.async_pipeline.get_result(next_frame_id_to_show)
+            if stop_visualization:
+                break
+            self.async_pipeline.submit_data(frame, next_frame_id, {"frame": frame})
+            next_frame_id += 1
+        self.async_pipeline.await_all()
+        for next_id in range(next_frame_id_to_show, next_frame_id):
+            start_time = time.perf_counter()
+            results = self.async_pipeline.get_result(next_id)
+            if not results:
+                msg = "Async pipeline returned None results"
+                raise RuntimeError(msg)
+            output = self.render_result(results)
+            self.visualizer.show(output)
+            if self.visualizer.output:
+                saved_frames.append(output)
+            # visualize video not faster than the original FPS
+            self.visualizer.video_delay(time.perf_counter() - start_time, streamer)
+        dump_frames(saved_frames, self.visualizer.output, input_stream, streamer)
+
+    def render_result(self, results: tuple[Any, dict]) -> np.ndarray:
+        """Render for results of inference."""
+        predictions, frame_meta = results
+        current_frame = frame_meta["frame"]
+        return self.visualizer.draw(current_frame, predictions)

deployments/deployment/Instance segmentation task/python/demo_package/executors/synchronous.py

@@ -0,0 +1,49 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Synchronous Executor based on ModelAPI."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from demo_package.model_wrapper import ModelWrapper
+    from demo_package.visualizers import BaseVisualizer
+
+from demo_package.streamer.streamer import get_streamer
+from demo_package.visualizers import dump_frames
+
+
+class SyncExecutor:
+    """Synchronous executor for model inference.
+
+    Args:
+        model (ModelContainer): model for inference
+        visualizer (Visualizer): visualizer of inference results. Defaults to None.
+    """
+
+    def __init__(self, model: ModelWrapper, visualizer: BaseVisualizer) -> None:
+        self.model = model
+        self.visualizer = visualizer
+
+    def run(self, input_stream: int | str, loop: bool = False) -> None:
+        """Run demo using input stream (image, video stream, camera)."""
+        streamer = get_streamer(input_stream, loop)
+        saved_frames = []
+
+        for frame in streamer:
+            # getting result include preprocessing, infer, postprocessing for sync infer
+            start_time = time.perf_counter()
+            predictions, _ = self.model(frame)
+            output = self.visualizer.draw(frame, predictions)
+            self.visualizer.show(output)
+            if output is not None:
+                saved_frames.append(output)
+            if self.visualizer.is_quit():
+                break
+            # visualize video not faster than the original FPS
+            self.visualizer.video_delay(time.perf_counter() - start_time, streamer)
+
+        dump_frames(saved_frames, self.visualizer.output, input_stream, streamer)

deployments/deployment/Instance segmentation task/python/demo_package/model_wrapper.py

@@ -0,0 +1,131 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""ModelContainer class used for loading the model in the model wrapper."""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, Any, NamedTuple
+
+from model_api.adapters import OpenvinoAdapter, create_core
+from model_api.models import Model
+
+from .utils import get_model_path, get_parameters
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    import numpy as np
+    from model_api.tilers import DetectionTiler, InstanceSegmentationTiler
+
+
+class TaskType(str, Enum):
+    """OTX task type definition."""
+
+    CLASSIFICATION = "CLASSIFICATION"
+    DETECTION = "DETECTION"
+    INSTANCE_SEGMENTATION = "INSTANCE_SEGMENTATION"
+    SEGMENTATION = "SEGMENTATION"
+
+
+class ModelWrapper:
+    """Class for storing the model wrapper based on Model API and needed parameters of model.
+
+    Args:
+        model_dir (Path): path to model directory
+    """
+
+    def __init__(self, model_dir: Path, device: str = "CPU") -> None:
+        model_adapter = OpenvinoAdapter(create_core(), get_model_path(model_dir / "model.xml"), device=device)
+        if not (model_dir / "config.json").exists():
+            msg = "config.json doesn't exist in the model directory."
+            raise RuntimeError(msg)
+        self.parameters = get_parameters(model_dir / "config.json")
+        self._labels = self.parameters["model_parameters"]["labels"]
+        self._task_type = TaskType[self.parameters["task_type"].upper()]
+
+        # labels for modelAPI wrappers can be empty, because unused in pre- and postprocessing
+        self.model_parameters = self.parameters["model_parameters"]
+
+        # model already contains correct labels
+        self.model_parameters.pop("labels")
+
+        self.core_model = Model.create_model(
+            model_adapter,
+            self.parameters["model_type"],
+            self.model_parameters,
+            preload=True,
+        )
+        self.tiler = self.setup_tiler(model_dir, device)
+
+    def setup_tiler(
+        self,
+        model_dir: Path,
+        device: str,
+    ) -> DetectionTiler | InstanceSegmentationTiler | None:
+        """Set up tiler for model.
+
+        Args:
+            model_dir (str): model directory
+            device (str): device to run model on
+        Returns:
+            Optional: type of tiler or None
+        """
+        if not self.parameters.get("tiling_parameters") or not self.parameters["tiling_parameters"]["enable_tiling"]:
+            return None
+
+        msg = "Tiling has not been implemented yet"
+        raise NotImplementedError(msg)
+
+    @property
+    def task_type(self) -> TaskType:
+        """Task type property."""
+        return self._task_type
+
+    @property
+    def labels(self) -> dict:
+        """Labels property."""
+        return self._labels
+
+    def infer(self, frame: np.ndarray) -> tuple[NamedTuple, dict]:
+        """Infer with original image.
+
+        Args:
+            frame: np.ndarray, input image
+        Returns:
+            predictions: NamedTuple, prediction
+            frame_meta: Dict, dict with original shape
+        """
+        # getting result include preprocessing, infer, postprocessing for sync infer
+        predictions = self.core_model(frame)
+        frame_meta = {"original_shape": frame.shape}
+
+        return predictions, frame_meta
+
+    def infer_tile(self, frame: np.ndarray) -> tuple[NamedTuple, dict]:
+        """Infer by patching full image to tiles.
+
+        Args:
+            frame: np.ndarray - input image
+        Returns:
+            Tuple[NamedTuple, Dict]: prediction and original shape
+        """
+        if self.tiler is None:
+            msg = "Tiler is not set"
+            raise RuntimeError(msg)
+        detections = self.tiler(frame)
+        return detections, {"original_shape": frame.shape}
+
+    def __call__(self, input_data: np.ndarray) -> tuple[Any, dict]:
+        """Call the ModelWrapper class.
+
+        Args:
+            input_data (np.ndarray): The input image.
+
+        Returns:
+            Tuple[Any, dict]: A tuple containing predictions and the meta information.
+        """
+        if self.tiler is not None:
+            return self.infer_tile(input_data)
+        return self.infer(input_data)

deployments/deployment/Instance segmentation task/python/demo_package/streamer/__init__.py

@@ -0,0 +1,24 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Initialization of streamer."""
+
+from .streamer import (
+    BaseStreamer,
+    CameraStreamer,
+    DirStreamer,
+    ImageStreamer,
+    ThreadedStreamer,
+    VideoStreamer,
+    get_streamer,
+)
+
+__all__ = [
+    "CameraStreamer",
+    "DirStreamer",
+    "ImageStreamer",
+    "ThreadedStreamer",
+    "VideoStreamer",
+    "BaseStreamer",
+    "get_streamer",
+]

deployments/deployment/Instance segmentation task/python/demo_package/streamer/streamer.py

@@ -0,0 +1,346 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Streamer for reading input."""
+
+from __future__ import annotations
+
+import abc
+import contextlib
+import multiprocessing
+import os
+import queue
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator
+
+if TYPE_CHECKING:
+    import numpy as np
+
+import cv2
+
+
+class MediaType(Enum):
+    """This Enum represents the types of input."""
+
+    IMAGE = 1
+    DIR = 2
+    VIDEO = 3
+    CAMERA = 4
+
+
+class BaseStreamer(metaclass=abc.ABCMeta):
+    """Base Streamer interface to implement Image, Video and Camera streamers."""
+
+    @abc.abstractmethod
+    def __init__(self, input_path: str, loop: bool = False) -> None:
+        """Initialize the streamer object.
+
+        Args:
+            input_path (str): path to the input stream
+            loop (bool, optional): whether to loop the stream or not. Defaults to False.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Iterate through the streamer object that is a Python Generator object.
+
+        Returns:
+            np.ndarray: Yield the image or video frame.
+        """
+        raise NotImplementedError
+
+    @abc.abstractmethod
+    def get_type(self) -> MediaType:
+        """Get type of streamer.
+
+        Returns:
+            MediaType: type of streamer.
+        """
+        raise NotImplementedError
+
+    def fps(self) -> float:
+        """Returns a frequency of getting images from source."""
+        raise NotImplementedError
+
+
+def _process_run(streamer: BaseStreamer, buffer: multiprocessing.Queue) -> None:
+    """Private function that is run by the thread.
+
+    Waits for the buffer to gain space for timeout seconds while it is full.
+    If no space was available within this time the function will exit
+
+    streamer (BaseStreamer): The streamer to retrieve frames from
+    buffer (multiprocessing.Queue): The buffer to place the retrieved frames in
+    """
+    for frame in streamer:
+        buffer.put(frame)
+
+
+class ThreadedStreamer(BaseStreamer):
+    """Runs a BaseStreamer on a separate thread.
+
+    streamer (BaseStreamer): The streamer to run on a thread
+    buffer_size (int): Number of frame to buffer internally. Defaults to 2.
+
+    Example:
+        >>> streamer = VideoStreamer(path="../demo.mp4")
+        >>> threaded_streamer = ThreadedStreamer(streamer)
+        >>> for frame in threaded_streamer:
+        ...    pass
+    """
+
+    def __init__(self, streamer: BaseStreamer, buffer_size: int = 2) -> None:
+        self.buffer_size = buffer_size
+        self.streamer = streamer
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Get frames from streamer and yield them.
+
+        Yields:
+            Iterator[np.ndarray]: Yield the image or video frame.
+        """
+        buffer: multiprocessing.Queue = multiprocessing.Queue(maxsize=self.buffer_size)
+        process = multiprocessing.Process(target=_process_run, args=(self.streamer, buffer))
+        # Make thread a daemon so that it will exit when the main program exits as well
+        process.daemon = True
+        process.start()
+
+        try:
+            with contextlib.suppress(queue.Empty):
+                while process.is_alive() or not buffer.empty():
+                    yield buffer.get(timeout=0.1)
+        except GeneratorExit:
+            process.terminate()
+        finally:
+            process.join(timeout=0.1)
+            # The kill() function is only available in Python 3.7.
+            # Skip it if running an older Python version.
+            if sys.version_info >= (3, 7) and process.exitcode is None:
+                process.kill()
+
+    def get_type(self) -> MediaType:
+        """Get type of internal streamer.
+
+        Returns:
+            MediaType: type of internal streamer.
+        """
+        return self.streamer.get_type()
+
+
+class VideoStreamer(BaseStreamer):
+    """Video Streamer.
+
+    Args:
+        path: Path to the video file.
+
+    Example:
+        >>> streamer = VideoStreamer(path="../demo.mp4")
+        ... for frame in streamer:
+        ...    pass
+    """
+
+    def __init__(self, input_path: str, loop: bool = False) -> None:
+        self.media_type = MediaType.VIDEO
+        self.loop = loop
+        self.cap = cv2.VideoCapture()
+        status = self.cap.open(input_path)
+        if not status:
+            msg = f"Can't open the video from {input_path}"
+            raise RuntimeError(msg)
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Iterates over frames of the video.
+
+        If self.loop is set to True, the video will loop infinitely.
+        """
+        while True:
+            status, image = self.cap.read()
+            if status:
+                yield cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+            elif self.loop:
+                self.cap.set(cv2.CAP_PROP_POS_FRAMES, 0)
+            else:
+                break
+
+    def fps(self) -> float:
+        """Returns a frequency of getting images from source."""
+        return self.cap.get(cv2.CAP_PROP_FPS)
+
+    def get_type(self) -> MediaType:
+        """Returns the type of media."""
+        return MediaType.VIDEO
+
+
+class CameraStreamer(BaseStreamer):
+    """Stream video frames from camera.
+
+    Args:
+        camera_device (int): Camera device index e.g, 0, 1
+
+    Example:
+        >>> streamer = CameraStreamer(camera_device=0)
+        ... for frame in streamer:
+        ...     cv2.imshow("Window", frame)
+        ...     if ord("q") == cv2.waitKey(1):
+        ...         break
+    """
+
+    def __init__(self, camera_device: str = "0") -> None:
+        self.media_type = MediaType.CAMERA
+        try:
+            self.stream = cv2.VideoCapture(int(camera_device))
+        except ValueError as err:
+            msg = f"Can't find the camera {camera_device}"
+            raise ValueError(msg) from err
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Read video and yield the frame.
+
+        Args:
+            stream: Video stream captured via OpenCV's VideoCapture
+
+        Returns:
+            Individual frame
+        """
+        while True:
+            frame_available, frame = self.stream.read()
+            if not frame_available:
+                break
+            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            yield frame
+
+        self.stream.release()
+
+    def get_type(self) -> MediaType:
+        """Returns the type of media."""
+        return MediaType.CAMERA
+
+
+class ImageStreamer(BaseStreamer):
+    """Stream from image file.
+
+    Args:
+        input_path (str): Path to an image.
+        loop (bool): Whether to loop through the image or not. Defaults to False.
+
+    Example:
+        >>> streamer = ImageStreamer(path="../images")
+        ... for frame in streamer:
+        ...     cv2.imshow("Window", frame)
+        ...     cv2.waitKey(0)
+    """
+
+    def __init__(self, input_path: str, loop: bool = False) -> None:
+        self.loop = loop
+        self.media_type = MediaType.IMAGE
+        if not Path(input_path).is_file():
+            msg = f"Can't find the image by {input_path}"
+            raise RuntimeError(msg)
+        self.image = cv2.imread(input_path, cv2.IMREAD_COLOR)
+        if self.image is None:
+            msg = f"Can't open the image from {input_path}"
+            raise RuntimeError(msg)
+        self.image = cv2.cvtColor(self.image, cv2.COLOR_BGR2RGB)
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """If loop is True, yield the image again and again."""
+        if not self.loop:
+            yield self.image
+        else:
+            while True:
+                yield self.image
+
+    def get_type(self) -> MediaType:
+        """Returns the type of the streamer."""
+        return MediaType.IMAGE
+
+
+class DirStreamer(BaseStreamer):
+    """Stream from directory of images.
+
+    Args:
+        path: Path to directory.
+
+    Example:
+        >>> streamer = DirStreamer(path="../images")
+        ... for frame in streamer:
+        ...     cv2.imshow("Window", frame)
+        ...     cv2.waitKey(0)
+    """
+
+    def __init__(self, input_path: str, loop: bool = False) -> None:
+        self.loop = loop
+        self.media_type = MediaType.DIR
+        self.dir = Path(input_path)
+        if not self.dir.is_dir():
+            msg = f"Can't find the dir by {input_path}"
+            raise RuntimeError(msg)
+        self.names = sorted(os.listdir(self.dir))
+        if not self.names:
+            msg = f"The dir {input_path} is empty"
+            raise RuntimeError(msg)
+        self.file_id = 0
+        for name in self.names:
+            filename = self.dir / name
+            image = cv2.imread(str(filename), cv2.IMREAD_COLOR)
+            if image is not None:
+                return
+        msg = f"Can't read the first image from {input_path}"
+        raise RuntimeError(msg)
+
+    def __iter__(self) -> Iterator[np.ndarray]:
+        """Iterates over the images in a directory.
+
+        If self.loop is True, it reiterates again from the first image in the directory.
+        """
+        while self.file_id < len(self.names):
+            filename = self.dir / self.names[self.file_id]
+            image = cv2.imread(str(filename), cv2.IMREAD_COLOR)
+            if self.file_id < len(self.names) - 1:
+                self.file_id = self.file_id + 1
+            else:
+                self.file_id = self.file_id + 1 if not self.loop else 0
+            if image is not None:
+                yield cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    def get_type(self) -> MediaType:
+        """Returns the type of the streamer."""
+        return MediaType.DIR
+
+
+def get_streamer(
+    input_stream: str,
+    loop: bool = False,
+    threaded: bool = False,
+) -> BaseStreamer:
+    """Get streamer object based on the file path or camera device index provided.
+
+    Args:
+        input_stream (str): Path to file or directory or index for camera.
+        loop (bool): Enable reading the input in a loop. Defaults to False.
+        threaded (bool): Run streaming on a separate thread. Threaded streaming option. Defaults to False.
+
+    Returns:
+        BaseStreamer: Streamer object.
+    """
+    errors: list[Exception] = []
+    streamer_types = (ImageStreamer, DirStreamer, VideoStreamer)
+    for reader in streamer_types:
+        try:
+            streamer = reader(input_stream, loop)  # type: ignore [abstract]
+            return ThreadedStreamer(streamer) if threaded else streamer
+        except RuntimeError as error:  # noqa: PERF203
+            errors.append(error)
+    try:
+        streamer = CameraStreamer(input_stream)
+        return ThreadedStreamer(streamer) if threaded else streamer
+    except RuntimeError as error:
+        errors.append(error)
+
+    if errors:
+        raise RuntimeError(errors)
+
+    sys.exit(1)

deployments/deployment/Instance segmentation task/python/demo_package/utils.py

@@ -0,0 +1,61 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Utils for demo."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .visualizers import (
+    BaseVisualizer,
+    ClassificationVisualizer,
+    InstanceSegmentationVisualizer,
+    ObjectDetectionVisualizer,
+    SemanticSegmentationVisualizer,
+)
+
+
+def get_model_path(path: Path | None) -> Path:
+    """Get path to model."""
+    model_path = path
+    if model_path is None:
+        model_path = Path(__file__).parent / "openvino.xml"
+    if not model_path.exists():
+        msg = "The path to the model was not found."
+        raise OSError(msg)
+
+    return model_path
+
+
+def get_parameters(path: Path | None) -> dict:
+    """Get hyper parameters to creating model."""
+    parameters_path = path
+    if parameters_path is None:
+        parameters_path = Path(__file__).parent / "config.json"
+    if not parameters_path.exists():
+        msg = "The path to the config was not found."
+        raise OSError(msg)
+
+    with Path.open(parameters_path, encoding="utf8") as file:
+        return json.load(file)
+
+
+def create_visualizer(
+    task_type: str,
+    labels: list,
+    no_show: bool = False,
+    output: str = "./outputs",
+) -> BaseVisualizer | None:
+    """Create visualizer according to kind of task."""
+    if task_type == "CLASSIFICATION":
+        return ClassificationVisualizer(window_name="Result", no_show=no_show, output=output)
+    if task_type == "SEGMENTATION":
+        return SemanticSegmentationVisualizer(window_name="Result", labels=labels, no_show=no_show, output=output)
+    if task_type == "INSTANCE_SEGMENTATION":
+        return InstanceSegmentationVisualizer(window_name="Result", labels=labels, no_show=no_show, output=output)
+    if task_type == "DETECTION":
+        return ObjectDetectionVisualizer(window_name="Result", labels=labels, no_show=no_show, output=output)
+    msg = "Visualizer for f{task_type} is not implemented"
+    raise NotImplementedError(msg)

deployments/deployment/Instance segmentation task/python/demo_package/visualizers/__init__.py

@@ -0,0 +1,22 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Initialization of visualizers."""
+
+from .vis_utils import dump_frames
+from .visualizer import (
+    BaseVisualizer,
+    ClassificationVisualizer,
+    InstanceSegmentationVisualizer,
+    ObjectDetectionVisualizer,
+    SemanticSegmentationVisualizer,
+)
+
+__all__ = [
+    "BaseVisualizer",
+    "dump_frames",
+    "ClassificationVisualizer",
+    "SemanticSegmentationVisualizer",
+    "InstanceSegmentationVisualizer",
+    "ObjectDetectionVisualizer",
+]

deployments/deployment/Instance segmentation task/python/demo_package/visualizers/vis_utils.py

@@ -0,0 +1,190 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""This module implements activation map."""
+
+from __future__ import annotations
+
+import colorsys
+import random
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+def get_actmap(
+    saliency_map: np.ndarray,
+    output_res: tuple | list,
+) -> np.ndarray:
+    """Get activation map (heatmap)  from saliency map.
+
+    It will return activation map from saliency map
+
+    Args:
+        saliency_map (np.ndarray): Saliency map with pixel values from 0-255
+        output_res (Union[tuple, list]): Output resolution
+
+    Returns:
+        saliency_map (np.ndarray): [H, W, 3] colormap, more red means more salient
+
+    """
+    if len(saliency_map.shape) == 3:
+        saliency_map = saliency_map[0]
+
+    saliency_map = cv2.resize(saliency_map, output_res)
+    return cv2.applyColorMap(saliency_map, cv2.COLORMAP_JET)
+
+
+def get_input_names_list(input_path: str | int, capture: cv2.VideoCapture) -> list[str]:
+    """Lists the filenames of all inputs for demo."""
+    # Web camera input
+    if isinstance(input_path, int):
+        return []
+    if "DIR" in str(capture.get_type()):
+        return [f.name for f in Path(input_path).iterdir() if f.is_file()]
+    return [Path(input_path).name]
+
+
+def dump_frames(saved_frames: list, output: str, input_path: str | int, capture: cv2.VideoCapture) -> None:
+    """Saves images/videos with predictions from saved_frames to output folder with proper names."""
+    # If no frames are saved, return
+    if not saved_frames:
+        return
+
+    # Create the output folder if it doesn't exist
+    output_path = Path(output)
+    if not output_path.exists():
+        output_path.mkdir(parents=True)
+
+    # Get the list of input names
+    filenames = get_input_names_list(input_path, capture)
+
+    # If the input is a video, save it as video
+    if "VIDEO" in str(capture.get_type()):
+        filename = filenames[0]
+        w, h, _ = saved_frames[0].shape
+        video_path = str(output_path / filename)
+        codec = cv2.VideoWriter_fourcc(*"mp4v")
+        out = cv2.VideoWriter(video_path, codec, capture.fps(), (h, w))
+        for frame in saved_frames:
+            out.write(frame)
+        out.release()
+        print(f"Video was saved to {video_path}")
+    # If the input is not a video, save each frame as an image
+    else:
+        if len(filenames) != len(saved_frames):
+            filenames = [f"output_{i}.jpeg" for i, _ in enumerate(saved_frames)]
+        for filename, frame in zip(filenames, saved_frames):
+            image_path = str(output_path / filename)
+            cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
+            cv2.imwrite(image_path, frame)
+            print(f"Image was saved to {image_path}")
+
+
+class ColorPalette:
+    """Represents a palette of colors."""
+
+    def __init__(self, num_classes: int, rng: random.Random | None = None) -> None:
+        """Initialize the ColorPalette.
+
+        Args:
+        - num_classes (int): The number of classes.
+        - rng (Optional[random.Random]): The random number generator.
+
+        Returns:
+        None
+        """
+        if num_classes <= 0:
+            msg = "ColorPalette accepts only the positive number of colors"
+            raise ValueError(msg)
+        if rng is None:
+            rng = random.Random(0xACE)  # nosec B311  # disable random check
+
+        candidates_num = 100
+        hsv_colors = [(1.0, 1.0, 1.0)]
+        for _ in range(1, num_classes):
+            colors_candidates = [
+                (rng.random(), rng.uniform(0.8, 1.0), rng.uniform(0.5, 1.0)) for _ in range(candidates_num)
+            ]
+            min_distances = [self._min_distance(hsv_colors, c) for c in colors_candidates]
+            arg_max = np.argmax(min_distances)
+            hsv_colors.append(colors_candidates[arg_max])
+
+        self.palette = [self.hsv2rgb(*hsv) for hsv in hsv_colors]
+
+    @staticmethod
+    def _dist(c1: tuple[float, float, float], c2: tuple[float, float, float]) -> float:
+        """Calculate the distance between two colors in 3D space.
+
+        Args:
+        - c1 (Tuple[float, float, float]): Tuple representing the first RGB color.
+        - c2 (Tuple[float, float, float]): Tuple representing the second RGB color.
+
+        Returns:
+        float: The distance between the two colors.
+        """
+        dh = min(abs(c1[0] - c2[0]), 1 - abs(c1[0] - c2[0])) * 2
+        ds = abs(c1[1] - c2[1])
+        dv = abs(c1[2] - c2[2])
+        return dh * dh + ds * ds + dv * dv
+
+    @classmethod
+    def _min_distance(
+        cls,
+        colors_set: list[tuple[float, float, float]],
+        color_candidate: tuple[float, float, float],
+    ) -> float:
+        """Calculate the minimum distance between color_candidate and colors_set.
+
+        Args:
+        - colors_set: List of tuples representing RGB colors.
+        - color_candidate: Tuple representing an RGB color.
+
+        Returns:
+        - float: The minimum distance between color_candidate and colors_set.
+        """
+        distances = [cls._dist(o, color_candidate) for o in colors_set]
+        return min(distances)
+
+    def to_numpy_array(self) -> np.ndarray:
+        """Convert the palette to a NumPy array.
+
+        Returns:
+        np.ndarray: The palette as a NumPy array.
+        """
+        return np.array(self.palette)
+
+    @staticmethod
+    def hsv2rgb(h: float, s: float, v: float) -> tuple[int, int, int]:
+        """Convert HSV color to RGB color.
+
+        Args:
+        - h (float): Hue.
+        - s (float): Saturation.
+        - v (float): Value.
+
+        Returns:
+        Tuple[int, int, int]: RGB color.
+        """
+        r, g, b = colorsys.hsv_to_rgb(h, s, v)
+        return int(r * 255), int(g * 255), int(b * 255)
+
+    def __getitem__(self, n: int) -> tuple[int, int, int]:
+        """Get the color at index n.
+
+        Args:
+        - n (int): Index.
+
+        Returns:
+        Tuple[int, int, int]: RGB color.
+        """
+        return self.palette[n % len(self.palette)]
+
+    def __len__(self) -> int:
+        """Returns the number of colors in the palette.
+
+        Returns:
+        int: The number of colors in the palette.
+        """
+        return len(self.palette)

deployments/deployment/Instance segmentation task/python/demo_package/visualizers/visualizer.py

@@ -0,0 +1,402 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""Visualizer for results of prediction."""
+
+from __future__ import annotations
+
+import logging as log
+import time
+from typing import TYPE_CHECKING, NamedTuple
+
+import cv2
+import numpy as np
+from model_api.performance_metrics import put_highlighted_text
+
+from .vis_utils import ColorPalette
+
+if TYPE_CHECKING:
+    from demo_package.streamer import BaseStreamer
+    from model_api.models.utils import (
+        ClassificationResult,
+        DetectionResult,
+        InstanceSegmentationResult,
+        SegmentedObject,
+    )
+
+
+class BaseVisualizer:
+    """Base class for visualizators."""
+
+    def __init__(
+        self,
+        window_name: str | None = None,
+        no_show: bool = False,
+        delay: int | None = None,
+        output: str = "./outputs",
+    ) -> None:
+        """Base class for visualizators.
+
+        Args:
+            window_name (str]): The name of the window. Defaults to None.
+            no_show (bool): Flag to indicate whether to show the window. Defaults to False.
+            delay (int]): The delay in seconds. Defaults to None.
+            output (str]): The output directory. Defaults to "./outputs".
+
+        Returns:
+            None
+        """
+        self.window_name = "Window" if window_name is None else window_name
+
+        self.delay = delay
+        self.no_show = no_show
+        if delay is None:
+            self.delay = 1
+        self.output = output
+
+    def draw(
+        self,
+        frame: np.ndarray,
+        predictions: NamedTuple,
+    ) -> np.ndarray:
+        """Draw annotations on the image.
+
+        Args:
+            frame: Input image
+            predictions: Annotations to be drawn on the input image
+
+        Returns:
+            Output image with annotations.
+        """
+        raise NotImplementedError
+
+    def show(self, image: np.ndarray) -> None:
+        """Show result image.
+
+        Args:
+            image (np.ndarray): Image to be shown.
+        """
+        if not self.no_show:
+            cv2.imshow(self.window_name, image)
+
+    def is_quit(self) -> bool:
+        """Check user wish to quit."""
+        if self.no_show:
+            return False
+
+        return ord("q") == cv2.waitKey(self.delay)
+
+    def video_delay(self, elapsed_time: float, streamer: BaseStreamer) -> None:
+        """Check if video frames were inferenced faster than the original video FPS and delay visualizer if so.
+
+        Args:
+            elapsed_time (float): Time spent on frame inference
+            streamer (BaseStreamer): Streamer object
+        """
+        if self.no_show:
+            return
+        if "VIDEO" in str(streamer.get_type()):
+            fps_num = streamer.fps()
+            orig_frame_time = 1 / fps_num
+            if elapsed_time < orig_frame_time:
+                time.sleep(orig_frame_time - elapsed_time)
+
+
+class ClassificationVisualizer(BaseVisualizer):
+    """Visualize the predicted classification labels by drawing the annotations on the input image.
+
+    Example:
+        >>> predictions = inference_model.predict(frame)
+        >>> output = visualizer.draw(frame, predictions)
+        >>> visualizer.show(output)
+    """
+
+    def draw(
+        self,
+        frame: np.ndarray,
+        predictions: ClassificationResult,
+    ) -> np.ndarray:
+        """Draw classification annotations on the image.
+
+        Args:
+            image: Input image
+            annotation: Annotations to be drawn on the input image
+
+        Returns:
+            Output image with annotations.
+        """
+        predictions = predictions.top_labels
+        if not any(predictions):
+            log.warning("There are no predictions.")
+            return frame
+
+        class_label = predictions[0][1]
+        font_scale = 0.7
+        label_height = cv2.getTextSize(class_label, cv2.FONT_HERSHEY_COMPLEX, font_scale, 2)[0][1]
+        initial_labels_pos = frame.shape[0] - label_height * (int(1.5 * len(predictions)) + 1)
+
+        if initial_labels_pos < 0:
+            initial_labels_pos = label_height
+            log.warning("Too much labels to display on this frame, some will be omitted")
+        offset_y = initial_labels_pos
+
+        header = "Label:     Score:"
+        label_width = cv2.getTextSize(header, cv2.FONT_HERSHEY_COMPLEX, font_scale, 2)[0][0]
+        put_highlighted_text(
+            frame,
+            header,
+            (frame.shape[1] - label_width, offset_y),
+            cv2.FONT_HERSHEY_COMPLEX,
+            font_scale,
+            (255, 0, 0),
+            2,
+        )
+
+        for idx, class_label, score in predictions:
+            label = f"{idx}. {class_label}    {score:.2f}"
+            label_width = cv2.getTextSize(label, cv2.FONT_HERSHEY_COMPLEX, font_scale, 2)[0][0]
+            offset_y += int(label_height * 1.5)
+            put_highlighted_text(
+                frame,
+                label,
+                (frame.shape[1] - label_width, offset_y),
+                cv2.FONT_HERSHEY_COMPLEX,
+                font_scale,
+                (255, 0, 0),
+                2,
+            )
+        return frame
+
+
+class SemanticSegmentationVisualizer(BaseVisualizer):
+    """Visualize the predicted segmentation labels by drawing the annotations on the input image.
+
+    Example:
+        >>> masks = inference_model.predict(frame)
+        >>> output = visualizer.draw(frame, masks)
+        >>> visualizer.show(output)
+    """
+
+    def __init__(
+        self,
+        labels: list[str],
+        window_name: str | None = None,
+        no_show: bool = False,
+        delay: int | None = None,
+        output: str = "./outputs",
+    ) -> None:
+        """Semantic segmentation visualizer.
+
+        Draws the segmentation masks on the input image.
+
+        Parameters:
+            labels (List[str]): List of labels.
+            window_name (str | None): Name of the window (default is None).
+            no_show (bool): Flag indicating whether to show the window (default is False).
+            delay (int | None): Delay in milliseconds (default is None).
+            output (str): Output path (default is "./outputs").
+
+        Returns:
+            None
+        """
+        super().__init__(window_name, no_show, delay, output)
+        self.color_palette = ColorPalette(len(labels)).to_numpy_array()
+        self.color_map = self._create_color_map()
+
+    def _create_color_map(self) -> np.ndarray:
+        classes = self.color_palette[:, ::-1]  # RGB to BGR
+        color_map = np.zeros((256, 1, 3), dtype=np.uint8)
+        classes_num = len(classes)
+        color_map[:classes_num, 0, :] = classes
+        color_map[classes_num:, 0, :] = np.random.uniform(0, 255, size=(256 - classes_num, 3))
+        return color_map
+
+    def _apply_color_map(self, input_2d_mask: np.ndarray) -> np.ndarray:
+        input_3d = cv2.merge([input_2d_mask, input_2d_mask, input_2d_mask])
+        return cv2.LUT(input_3d.astype(np.uint8), self.color_map)
+
+    def draw(self, frame: np.ndarray, masks: SegmentedObject) -> np.ndarray:
+        """Draw segmentation annotations on the image.
+
+        Args:
+            frame: Input image
+            masks: Mask annotations to be drawn on the input image
+
+        Returns:
+            Output image with annotations.
+        """
+        masks = masks.resultImage
+        output = self._apply_color_map(masks)
+        return cv2.addWeighted(frame, 0.5, output, 0.5, 0)
+
+
+class ObjectDetectionVisualizer(BaseVisualizer):
+    """Visualizes object detection annotations on an input image."""
+
+    def __init__(
+        self,
+        labels: list[str],
+        window_name: str | None = None,
+        no_show: bool = False,
+        delay: int | None = None,
+        output: str = "./outputs",
+    ) -> None:
+        """Object detection visualizer.
+
+        Draws the object detection annotations on the input image.
+
+        Parameters:
+            labels (List[str]): The list of labels.
+            window_name (str | None): The name of the window. Defaults to None.
+            no_show (bool): Flag to control whether to show the window. Defaults to False.
+            delay (int | None): The delay in milliseconds. Defaults to None.
+            output (str): The output directory. Defaults to "./outputs".
+
+        Returns:
+            None
+        """
+        super().__init__(window_name, no_show, delay, output)
+        self.labels = labels
+        self.color_palette = ColorPalette(len(labels))
+
+    def draw(
+        self,
+        frame: np.ndarray,
+        predictions: DetectionResult,
+    ) -> np.ndarray:
+        """Draw instance segmentation annotations on the image.
+
+        Args:
+            image: Input image
+            annotation: Annotations to be drawn on the input image
+
+        Returns:
+            Output image with annotations.
+        """
+        for detection in predictions.objects:
+            class_id = int(detection.id)
+            color = self.color_palette[class_id]
+            det_label = self.color_palette[class_id] if self.labels and len(self.labels) >= class_id else f"#{class_id}"
+            xmin, ymin, xmax, ymax = detection.xmin, detection.ymin, detection.xmax, detection.ymax
+            cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
+            cv2.putText(
+                frame,
+                f"{det_label} {detection.score:.1%}",
+                (xmin, ymin - 7),
+                cv2.FONT_HERSHEY_COMPLEX,
+                0.6,
+                color,
+                1,
+            )
+
+        return frame
+
+
+class InstanceSegmentationVisualizer(BaseVisualizer):
+    """Visualizes Instance Segmentation annotations on an input image."""
+
+    def __init__(
+        self,
+        labels: list[str],
+        window_name: str | None = None,
+        no_show: bool = False,
+        delay: int | None = None,
+        output: str = "./outputs",
+    ) -> None:
+        """Instance segmentation visualizer.
+
+        Draws the instance segmentation annotations on the input image.
+
+        Args:
+            labels (List[str]): The list of labels.
+            window_name (str]): The name of the window. Defaults to None.
+            no_show (bool): A flag to indicate whether to show the window. Defaults to False.
+            delay (int]): The delay in milliseconds. Defaults to None.
+            output (str]): The path to the output directory. Defaults to "./outputs".
+
+        Returns:
+            None
+        """
+        super().__init__(window_name, no_show, delay, output)
+        self.labels = labels
+        colors_num = len(labels) if labels else 80
+        self.show_boxes = False
+        self.show_scores = True
+        self.palette = ColorPalette(colors_num)
+
+    def draw(
+        self,
+        frame: np.ndarray,
+        predictions: InstanceSegmentationResult,
+    ) -> np.ndarray:
+        """Draw the instance segmentation results on the input frame.
+
+        Args:
+            frame: np.ndarray - The input frame on which to draw the instance segmentation results.
+            predictions: InstanceSegmentationResult - The instance segmentation results to be drawn.
+
+        Returns:
+            np.ndarray - The input frame with the instance segmentation results drawn on it.
+        """
+        result = frame.copy()
+        output_objects = predictions.segmentedObjects
+        bboxes = [[output.xmin, output.ymin, output.xmax, output.ymax] for output in output_objects]
+        scores = [output.score for output in output_objects]
+        masks = [output.mask for output in output_objects]
+        label_names = [output.str_label for output in output_objects]
+
+        result = self._overlay_masks(result, masks)
+        return self._overlay_labels(result, bboxes, label_names, scores)
+
+    def _overlay_masks(self, image: np.ndarray, masks: list[np.ndarray]) -> np.ndarray:
+        segments_image = image.copy()
+        aggregated_mask = np.zeros(image.shape[:2], dtype=np.uint8)
+        aggregated_colored_mask = np.zeros(image.shape, dtype=np.uint8)
+        all_contours = []
+
+        for i, mask in enumerate(masks):
+            contours = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)[-2]
+            if contours:
+                all_contours.append(contours[0])
+
+            mask_color = self.palette[i]
+            cv2.bitwise_or(aggregated_mask, mask, dst=aggregated_mask)
+            cv2.bitwise_or(aggregated_colored_mask, mask_color, dst=aggregated_colored_mask, mask=mask)
+
+        # Fill the area occupied by all instances with a colored instances mask image
+        cv2.bitwise_and(segments_image, (0, 0, 0), dst=segments_image, mask=aggregated_mask)
+        cv2.bitwise_or(segments_image, aggregated_colored_mask, dst=segments_image, mask=aggregated_mask)
+
+        cv2.addWeighted(image, 0.5, segments_image, 0.5, 0, dst=image)
+        cv2.drawContours(image, all_contours, -1, (0, 0, 0))
+        return image
+
+    def _overlay_boxes(self, image: np.ndarray, boxes: list[np.ndarray], classes: list[int]) -> np.ndarray:
+        for box, class_id in zip(boxes, classes):
+            color = self.palette[class_id]
+            top_left, bottom_right = box[:2], box[2:]
+            image = cv2.rectangle(image, top_left, bottom_right, color, 2)
+        return image
+
+    def _overlay_labels(
+        self,
+        image: np.ndarray,
+        boxes: list[np.ndarray],
+        classes: list[str],
+        scores: list[float],
+    ) -> np.ndarray:
+        template = "{}: {:.2f}" if self.show_scores else "{}"
+
+        for box, score, label in zip(boxes, scores, classes):
+            text = template.format(label, score)
+            textsize = cv2.getTextSize(text, cv2.FONT_HERSHEY_SIMPLEX, 0.5, 1)[0]
+            cv2.putText(
+                image,
+                text,
+                (box[0], box[1] + int(textsize[0] / 3)),
+                cv2.FONT_HERSHEY_SIMPLEX,
+                0.5,
+                (255, 255, 255),
+                1,
+            )
+        return image

deployments/deployment/Instance segmentation task/python/requirements.txt

@@ -0,0 +1,3 @@
+openvino==2024.3.0
+openvino-model-api==0.2.5
+numpy==1.26.4

deployments/deployment/Instance segmentation task/python/setup.py

@@ -0,0 +1,30 @@
+# Copyright (C) 2024 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+"""setup file for demo package."""
+
+from pathlib import Path
+
+from setuptools import find_packages, setup
+
+SETUP_DIR = Path(__file__).resolve().parent
+
+with Path.open(SETUP_DIR / "requirements.txt", encoding="utf8") as f:
+    required = f.read().splitlines()
+
+packages = find_packages(str(SETUP_DIR))
+package_dir = {packages[0]: str(SETUP_DIR / packages[0])}
+
+setup(
+    name=packages[0],
+    version="0.0",
+    author="Intel® Corporation",
+    license="Copyright (c) 2024 Intel Corporation. SPDX-License-Identifier: Apache-2.0",
+    description="Demo based on ModelAPI classes",
+    packages=packages,
+    package_dir=package_dir,
+    package_data={
+        packages[0]: ["*.json"],
+    },
+    install_requires=required,
+)

deployments/deployment/project.json

@@ -0,0 +1,77 @@
+{
+   "id": "6483114c18fb8c1c529bd149",
+   "name": "eggs!",
+   "creation_time": "2023-06-09T11:47:24.780000+00:00",
+   "creator_id": "dd725a2c-b183-4616-bcf3-0894843fb6a5",
+   "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"
+         }
+      ]
+   },
+   "thumbnail": "/api/v1/organizations/0ec46502-f590-4358-afff-a6beb25fe89f/workspaces/97ecb1e9-4367-4bc6-b335-1c6e7aedbf77/projects/6483114c18fb8c1c529bd149/thumbnail",
+   "performance": {
+      "score": 0.9520755876647748,
+      "task_performances": [
+         {
+            "task_id": "6483114c18fb8c1c529bd14d",
+            "score": {
+               "value": 0.9520755876647748,
+               "metric_type": "Dice"
+            }
+         }
+      ]
+   },
+   "storage_info": {},
+   "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"
+      }
+   ]
+}

deployments/example_code/demo.py

@@ -0,0 +1,34 @@
+# 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.
+
+import cv2
+from geti_sdk.deployment import Deployment
+from geti_sdk.utils import show_image_with_annotation_scene
+
+if __name__ == "__main__":
+    # Step 1: Load the deployment
+    deployment = Deployment.from_folder("../deployment")
+
+    # Step 2: Load the sample image
+    image = cv2.imread("../sample_image.jpg")
+    image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+    # Step 3: Send inference model(s) to CPU
+    deployment.load_inference_models(device="CPU")
+
+    # Step 4: Infer image
+    prediction = deployment.infer(image_rgb)
+
+    # Step 5: Visualization
+    show_image_with_annotation_scene(image_rgb, prediction)

deployments/example_code/demo_notebook.ipynb

@@ -0,0 +1,156 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "86111f81-16f5-46e5-9010-1ef9e05a1571",
+   "metadata": {
+    "copyright": [
+     "INTEL CONFIDENTIAL",
+     "Copyright (C) 2022 Intel Corporation",
+     "This software and the related documents are Intel copyrighted materials, and your use of them is governed by",
+     "the express license under which they were provided to you (\"License\"). Unless the License provides otherwise,",
+     "you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related documents",
+     "without Intel's prior written permission.",
+     "This software and the related documents are provided as is, with no express or implied warranties,",
+     "other than those that are expressly stated in the License."
+    ]
+   },
+   "source": [
+    "# Intel® Geti™ deployment demo notebook\n",
+    "This notebook demonstrates how to run inference for a deployed Intel® Geti™ project on your local machine. It contains the following steps:\n",
+    "1. Load the deployment for the project from the exported `deployment` folder\n",
+    "2. Load a sample image to run inference on\n",
+    "3. Prepare the deployment for inference by sending the model (or models) for the project to the CPU\n",
+    "4. Infer image\n",
+    "5. Visualize prediction"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0ee561b-49fb-4f8b-9c7f-e4859e3fe99e",
+   "metadata": {},
+   "source": [
+    "### Step 1: Load the deployment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d04d3e58-8cae-4491-86b6-fbc876fd5e4f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from geti_sdk.deployment import Deployment\n",
+    "\n",
+    "deployment = Deployment.from_folder(\"../deployment\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "713de7c8-0ac4-4865-b947-98ecbc4173fb",
+   "metadata": {},
+   "source": [
+    "### Step 2: Load the sample image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5c61e01f-2c88-4f0d-ae18-88610cc13bf2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "\n",
+    "image = cv2.imread(\"../sample_image.jpg\")\n",
+    "image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40da9013-46f7-488d-972d-5ceddd54a60c",
+   "metadata": {},
+   "source": [
+    "### Step 3: Send inference model(s) to CPU"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f6b80e6f-57fa-421a-b71f-ffbd0847c0a9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "deployment.load_inference_models(device='CPU')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6f539adc-04e7-43b4-b113-99e7ff7f6482",
+   "metadata": {},
+   "source": [
+    "### Step 4: Infer image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a0e72d41-ec75-4bfe-859b-7302463b9fb6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "prediction = deployment.infer(image_rgb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f450bb5-29dc-4ac4-b5bb-4b02f350aacc",
+   "metadata": {},
+   "source": [
+    "### Step 5: Visualization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "db0dd922-36aa-4203-bc02-76c17d12d8be",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from geti_sdk.utils import show_image_with_annotation_scene\n",
+    "\n",
+    "show_image_with_annotation_scene(image_rgb, prediction, show_in_notebook=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a342324f-3177-4d61-bee4-40b47d0f78f8",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "celltoolbar": "Edit Metadata",
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

deployments/example_code/demo_ovms.ipynb

@@ -0,0 +1,421 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "copyright": [
+     "INTEL CONFIDENTIAL",
+     "Copyright (C) 2023 Intel Corporation",
+     "This software and the related documents are Intel copyrighted materials, and your use of them is governed by",
+     "the express license under which they were provided to you (\"License\"). Unless the License provides otherwise,",
+     "you may not use, modify, copy, publish, distribute, disclose or transmit this software or the related documents",
+     "without Intel's prior written permission.",
+     "This software and the related documents are provided as is, with no express or implied warranties,",
+     "other than those that are expressly stated in the License."
+    ]
+   },
+   "source": [
+    "# Serving Intel® Geti™ models with OpenVINO Model Server\n",
+    "This notebook shows how to set up an OpenVINO model server to serve the models trained\n",
+    "in your Intel® Geti™ project. It also shows how to use the Geti SDK as a client to\n",
+    "make inference requests to the model server.\n",
+    "\n",
+    "# Contents\n",
+    "\n",
+    "1. **OpenVINO Model Server**\n",
+    "    1. Requirements\n",
+    "    2. Generating the model server configuration\n",
+    "    3. Launching the model server\n",
+    "\n",
+    "2. **OVMS inference with Geti SDK**\n",
+    "    1. Loading inference model and sample image\n",
+    "    2. Requesting inference\n",
+    "    3. Inspecting the results\n",
+    "\n",
+    "3. **Conclusion**\n",
+    "    1. Cleaning up\n",
+    "\n",
+    "> **NOTE**: This notebook will set up a model server on the same machine that will be\n",
+    "> used as a client to request inference. In a real scenario you'd most likely\n",
+    "> want the server and the client to be different physical machines. The steps to set up\n",
+    "> OVMS on a remote server are the same as for the local server outlined in this\n",
+    "> notebook, but additional network configuration and security measures are most likely\n",
+    "> required.\n",
+    "\n",
+    "# OpenVINO Model Server\n",
+    "## Requirements\n",
+    "We will be running the OpenVINO Model Server (OVMS) with Docker. Please make sure you\n",
+    "have docker available on your system. You can install it by following the instructions\n",
+    "[here](https://docs.docker.com/get-docker/).\n",
+    "\n",
+    "## Generating the model server configuration\n",
+    "The `deployment` that was downloaded from the Intel® Geti™ platform can be used to create\n",
+    "the configuration files that are needed to set up an OpenVINO model server for your project.\n",
+    "\n",
+    "The cell below shows how to create the configuration. Running this cell should create\n",
+    "a folder called `ovms_models` in a temporary directory. The `ovms_models` folder\n",
+    "contains the models and the configuration files required to run OVMS for the Intel®\n",
+    "Geti™ project."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import tempfile\n",
+    "\n",
+    "from geti_sdk.deployment import Deployment\n",
+    "\n",
+    "deployment_path = os.path.join(\"..\", \"deployment\")\n",
+    "\n",
+    "# Load the Geti deployment\n",
+    "deployment = Deployment.from_folder(deployment_path)\n",
+    "\n",
+    "# Creating the OVMS configuration for the deployment\n",
+    "# First, we'll create a temporary directory to store the config files\n",
+    "ovms_config_path = os.path.join(tempfile.mkdtemp(), \"ovms_models\")\n",
+    "\n",
+    "# Next, we generate the OVMS configuration and save it\n",
+    "deployment.generate_ovms_config(output_folder=ovms_config_path)\n",
+    "\n",
+    "print(f\"Configuration for OpenVINO Model Server was created at '{ovms_config_path}'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Launching the model server\n",
+    "As mentioned before, we will run OVMS in a Docker container. First, we need to make sure\n",
+    "that we have the latest OVMS image on our system. Run the cell below to pull the image."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "! docker pull openvino/model_server:latest"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "Next, we have to start the container with the configuration that we just generated. This\n",
+    "is done in the cell below.\n",
+    "\n",
+    "> NOTE: The cell below starts the OVMS container and sets it up to listen for inference\n",
+    "> requests on port 9000 on your system. If this port is already occupied the `docker run`\n",
+    "> command will fail and you may need to try a different port number."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Launch the OVMS container\n",
+    "result = ! docker run -d --rm -v {ovms_config_path}:/models -p 9000:9000 --name ovms_demo openvino/model_server:latest --port 9000 --config_path /models/ovms_model_config.json\n",
+    "\n",
+    "# Check that the container was created successfully\n",
+    "if len(result) == 1:\n",
+    "    container_id = result[0]\n",
+    "    print(f\"OVMS container with ID '{container_id}' created.\")\n",
+    "else:\n",
+    "    # Anything other than 1 result indicates that something went wrong\n",
+    "    raise RuntimeError(result)\n",
+    "\n",
+    "# Check that the container is running properly\n",
+    "container_info = ! docker container inspect {container_id}\n",
+    "container_status = str(container_info.grep(\"Status\"))\n",
+    "\n",
+    "if not container_status or not \"running\" in container_status:\n",
+    "    raise RuntimeError(\n",
+    "        f\"Invalid ovms docker container status found: {container_status}. Most \"\n",
+    "        f\"likely the container has not started properly.\"\n",
+    "    )\n",
+    "print(\"OVMS container is up and running.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "That's it! If all went well the cell above should print the ID of the container that\n",
+    "was created. This can be used to identify your container if you have a lot of docker\n",
+    "containers running on your system.\n",
+    "\n",
+    "# OVMS inference with Geti SDK\n",
+    "Now that the OVMS container is running, we can use the Geti SDK to talk to it and make an\n",
+    "inference request. The remaining part of this notebook shows how to do so.\n",
+    "\n",
+    "## Loading inference model and sample image\n",
+    "In the first part of this notebook we created configuration files for OVMS, using the\n",
+    "`deployment` that was generated for your Intel® Geti™ project. To do inference, we need\n",
+    "to connect the deployment to the OVMS container that is now running. This is done in the\n",
+    "cell below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Load the inference models by connecting to OVMS on port 9000\n",
+    "deployment.load_inference_models(device=\"http://localhost:9000\")\n",
+    "\n",
+    "print(\"Connected to OpenVINO Model Server.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "You should see some output indicating that the connection to OVMS was made successfully.\n",
+    "If you see any errors at this stage, make sure your OVMS container is running and that the\n",
+    "port number is correct.\n",
+    "\n",
+    "Next up, we'll load a sample image from the project to run inference on"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import cv2\n",
+    "\n",
+    "# Load the sample image\n",
+    "image = cv2.imread(\"../sample_image.jpg\")\n",
+    "image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
+    "\n",
+    "# Show the image in the notebook\n",
+    "from IPython.display import display\n",
+    "from PIL import Image\n",
+    "\n",
+    "display(Image.fromarray(image_rgb))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Requesting inference\n",
+    "Now that everything is set up, making an inference request is very simple:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import time\n",
+    "\n",
+    "t_start = time.time()\n",
+    "prediction = deployment.infer(image_rgb)\n",
+    "t_end = time.time()\n",
+    "\n",
+    "print(\n",
+    "    f\"OVMS inference on sample image completed in {(t_end - t_start) * 1000:.1f} milliseconds.\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "## Inspecting the results\n",
+    "Note that the code to request inference is exactly the same as for the case when the model\n",
+    "is loaded on the CPU (see `demo_notebook.ipynb`). Like The `prediction` can be shown using\n",
+    "the Geti SDK visualization utility function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false,
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from geti_sdk.utils import show_image_with_annotation_scene\n",
+    "\n",
+    "show_image_with_annotation_scene(image_rgb, prediction, show_in_notebook=True);"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "jupyter": {
+     "outputs_hidden": false
+    },
+    "pycharm": {
+     "name": "#%% md\n"
+    }
+   },
+   "source": [
+    "# Conclusion\n",
+    "That's all there is to it! Of course in practice the client would request inference\n",
+    "from an OpenVINO model server on a different physical machine, in contrast to the\n",
+    "example here where client and server are running on the same machine.\n",
+    "\n",
+    "The steps outlined in this notebook can be used as a basis to set up a remote\n",
+    "client/server combination, but please note that additional network configuration will\n",
+    "be required (along with necessary security measures).\n",
+    "\n",
+    "## Cleaning up\n",
+    "To clean up, we'll stop the OVMS docker container that we started. This will\n",
+    "automatically remove the container. After that, we'll delete the temporary directory\n",
+    "we created to store the config files."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Stop the container\n",
+    "result = ! docker stop {container_id}\n",
+    "\n",
+    "# Check if removing the container worked correctly\n",
+    "if result[0] == container_id:\n",
+    "    print(f\"OVMS container '{container_id}' stopped and removed successfully.\")\n",
+    "else:\n",
+    "    print(\n",
+    "       \"An error occurred while removing OVMS docker container. Most likely the container \"\n",
+    "       \"was already removed. \"\n",
+    "    )\n",
+    "    print(f\"The docker daemon responded with the following error: \\n{result}\")\n",
+    "    \n",
+    "# Remove the temporary directory with the OVMS configuration\n",
+    "import shutil\n",
+    "\n",
+    "temp_dir = os.path.dirname(ovms_config_path)\n",
+    "try:\n",
+    "    shutil.rmtree(temp_dir)\n",
+    "    print(\"Temporary configuration directory removed successfully.\")\n",
+    "except FileNotFoundError:\n",
+    "    print(\n",
+    "        f\"Temporary directory with OVMS configuration '{temp_dir}' was \"\n",
+    "        f\"not found on the system. Most likely it is already removed.\"\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.16"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

deployments/example_code/requirements-notebook.txt

@@ -0,0 +1,6 @@
+# Requirements for running the `demo_notebook.ipynb` and `demo_ovms.ipynb` Jupyter notebooks
+geti-sdk==2.6.*
+jupyterlab>=3.6
+opencv-python>=4.10
+Pillow>=9.4.0
+ipython>=8.10.0

deployments/example_code/requirements.txt

@@ -0,0 +1,3 @@
+# Base requirements for the deployment
+geti-sdk==2.6.*
+opencv-python>=4.10