Publishing R3

inference-engine/ie_bridges/python/sample/affinity_setting_sample.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+import logging as log
+from openvino.inference_engine import IENetwork, IEPlugin
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input", help="Path to a folder with images or path to an image files", required=True,
+                        type=str)
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify hetero plugin configuration; e.g. HETERO:FPGA,CPU", default="HETERO:CPU,GPU",
+                        type=str)
+    parser.add_argument("-nt", "--number_top", help="Number of top results", default=10, type=int)
+
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    assert args.device.split(':')[0] == "HETERO", "This sample supports only Hetero Plugin. " \
+                                                  "Please specify correct device, e.g. HETERO:FPGA,CPU"
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+    # Read IR
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+    net_ops = set([l.type for l in net.layers.values()])
+    if not any([op == "Convolution" for op in net_ops]):
+        log.warning("Specified IR doesn't contain any Convolution operations for which affinity going to be set.\n"
+                    "Try to use another topology to make the affinity setting result more visible.")
+
+    # Configure the plugin to initialize default affinity for network in set_initial_affinity() function.
+    plugin.set_config({"TARGET_FALLBACK": args.device.split(':')[1]})
+    # Enable graph visualization
+    plugin.set_config({"HETERO_DUMP_GRAPH_DOT": "YES"})
+    plugin.set_initial_affinity(net)
+
+    for l in net.layers.values():
+        if l.type == "Convolution":
+            l.affinity = "GPU"
+
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    # Read and pre-process input image
+    n, c, h, w = net.inputs[input_blob]
+    image = cv2.imread(args.input)
+    image = cv2.resize(image, (w, h))
+    image = image.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+    image = image.reshape((n, c, h, w))
+    # Load network to the plugin
+    exec_net = plugin.load(network=net)
+    del net
+    # Start sync inference
+    res = exec_net.infer(inputs={input_blob: image})
+    top_ind = np.argsort(res[out_blob], axis=1)[0, -args.number_top:][::-1]
+    for i in top_ind:
+        log.info("%f #%d" % (res[out_blob][0, i], i))
+    del exec_net
+    del plugin
+    cwd = os.getcwd()
+    log.info(
+        "Graphs representing default and resulting affinities dumped to {} and {} files respectively"
+            .format(os.path.join(cwd, 'hetero_affinity.dot'), os.path.join(cwd, 'hetero_subgraphs.dot'))
+    )
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/classification_sample.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+import logging as log
+from time import time
+from openvino.inference_engine import IENetwork, IEPlugin
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input", help="Path to a folder with images or path to an image files", required=True,
+                        type=str, nargs="+")
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample "
+                             "will look for a suitable plugin for device specified (CPU by default)", default="CPU",
+                        type=str)
+    parser.add_argument("--labels", help="Labels mapping file", default=None, type=str)
+    parser.add_argument("-nt", "--number_top", help="Number of top results", default=10, type=int)
+    parser.add_argument("-ni", "--number_iter", help="Number of inference iterations", default=1, type=int)
+    parser.add_argument("-pc", "--perf_counts", help="Report performance counters", default=False, action="store_true")
+
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+    # Read IR
+    log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+
+    log.info("Preparing input blobs")
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    net.batch_size = len(args.input)
+
+    # Read and pre-process input images
+    n, c, h, w = net.inputs[input_blob]
+    images = np.ndarray(shape=(n, c, h, w))
+    for i in range(n):
+        image = cv2.imread(args.input[i])
+        if image.shape[:-1] != (h, w):
+            log.warning("Image {} is resized from {} to {}".format(args.input[i], image.shape[:-1], (h, w)))
+            image = cv2.resize(image, (w, h))
+        image = image.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        images[i] = image
+    log.info("Batch size is {}".format(n))
+
+    # Loading model to the plugin
+    log.info("Loading model to the plugin")
+    exec_net = plugin.load(network=net)
+    del net
+
+    # Start sync inference
+    log.info("Starting inference ({} iterations)".format(args.number_iter))
+    infer_time = []
+    for i in range(args.number_iter):
+        t0 = time()
+        res = exec_net.infer(inputs={input_blob: images})
+        infer_time.append((time()-t0)*1000)
+    log.info("Average running time of one iteration: {} ms".format(np.average(np.asarray(infer_time))))
+    if args.perf_counts:
+        perf_counts = exec_net.requests[0].get_perf_counts()
+        log.info("Performance counters:")
+        print("{:<70} {:<15} {:<15} {:<15} {:<10}".format('name', 'layer_type', 'exet_type', 'status', 'real_time, us'))
+        for layer, stats in perf_counts.items():
+            print ("{:<70} {:<15} {:<15} {:<15} {:<10}".format(layer, stats['layer_type'], stats['exec_type'],
+                                                               stats['status'], stats['real_time']))
+
+    # Processing output blob
+    log.info("Processing output blob")
+    res = res[out_blob]
+    log.info("Top {} results: ".format(args.number_top))
+    if args.labels:
+        with open(args.labels, 'r') as f:
+            labels_map = [x.split(sep=' ', maxsplit=1)[-1].strip() for x in f]
+    else:
+        labels_map = None
+    for i, probs in enumerate(res):
+        probs = np.squeeze(probs)
+        top_ind = np.argsort(probs)[-args.number_top:][::-1]
+        print("Image {}\n".format(args.input[i]))
+        for id in top_ind:
+            det_label = labels_map[id] if labels_map else "#{}".format(id)
+            print("{:.7f} label {}".format(probs[id], det_label))
+        print("\n")
+
+    del exec_net
+    del plugin
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/classification_sample_async.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+import logging as log
+from time import time
+from openvino.inference_engine import IENetwork, IEPlugin
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input", help="Path to a folder with images or path to an image files", required=True,
+                        type=str, nargs="+")
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample "
+                             "will look for a suitable plugin for device specified (CPU by default)", default="CPU",
+                        type=str)
+    parser.add_argument("--labels", help="Labels mapping file", default=None, type=str)
+    parser.add_argument("-nt", "--number_top", help="Number of top results", default=10, type=int)
+    parser.add_argument("-ni", "--number_iter", help="Number of inference iterations", default=1, type=int)
+    parser.add_argument("-pc", "--perf_counts", help="Report performance counters", default=False, action="store_true")
+
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+    # Read IR
+    log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+
+    log.info("Preparing input blobs")
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    net.batch_size = len(args.input)
+
+    # Read and pre-process input images
+    n, c, h, w = net.inputs[input_blob]
+    images = np.ndarray(shape=(n, c, h, w))
+    for i in range(n):
+        image = cv2.imread(args.input[i])
+        if image.shape[:-1] != (h, w):
+            log.warning("Image {} is resized from {} to {}".format(args.input[i], image.shape[:-1], (h, w)))
+            image = cv2.resize(image, (w, h))
+        image = image.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        images[i] = image
+    log.info("Batch size is {}".format(n))
+
+    # Loading model to the plugin
+    log.info("Loading model to the plugin")
+    exec_net = plugin.load(network=net)
+    del net
+
+    # Start sync inference
+    log.info("Starting inference ({} iterations)".format(args.number_iter))
+    infer_time = []
+    for i in range(args.number_iter):
+        t0 = time()
+        infer_request_handle = exec_net.start_async(request_id=0, inputs={input_blob: images})
+        infer_request_handle.wait()
+        infer_time.append((time() - t0) * 1000)
+    log.info("Average running time of one iteration: {} ms".format(np.average(np.asarray(infer_time))))
+    if args.perf_counts:
+        perf_counts = infer_request_handle.get_perf_counts()
+        log.info("Performance counters:")
+        print ("{:<70} {:<15} {:<15} {:<15} {:<10}".format('name', 'layer_type', 'exet_type', 'status', 'real_time, us'))
+        for layer, stats in perf_counts.items():
+            print ("{:<70} {:<15} {:<15} {:<15} {:<10}".format(layer, stats['layer_type'], stats['exec_type'],
+                                                               stats['status'], stats['real_time']))
+    # Processing output blob
+    log.info("Processing output blob")
+    res = infer_request_handle.outputs[out_blob]
+    log.info("Top {} results: ".format(args.number_top))
+    if args.labels:
+        with open(args.labels, 'r') as f:
+            labels_map = [x.split(sep=' ', maxsplit=1)[-1].strip() for x in f]
+    else:
+        labels_map = None
+    for i, probs in enumerate(res):
+        probs = np.squeeze(probs)
+        top_ind = np.argsort(probs)[-args.number_top:][::-1]
+        print("Image {}\n".format(args.input[i]))
+        for id in top_ind:
+            det_label = labels_map[id] if labels_map else "#{}".format(id)
+            print("{:.7f} {}".format(probs[id], det_label))
+        print("\n")
+
+    del exec_net
+    del plugin
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/greengrass_samples/README.md

@@ -0,0 +1,49 @@
+# This README demonstrates use of all GreenGrass samples
+ 
+# GreenGrass Classification Sample
+
+This topic demonstrates how to build and run the GreenGrass Image Classification sample application, which does inference using image classification networks like AlexNet and GoogLeNet on on Intel® Processors, Intel® HD Graphics and Intel® FPGA.
+
+## Running
+
+1. Modify the "accelerator" parameter inside the sample to deploy the sample on any accelerator option of your choice(CPU/GPU/FPGA)  
+   For CPU, please specify "CPU"  
+   For GPU, please specify "GPU"  
+   For FPGA, please specify "HETERO:FPGA,CPU"  
+2. Enable the option(s) on how output is displayed/consumed 
+3. Now follow the instructions listed in the Greengrass-FaaS-User-Guide.pdf to create the lambda and deploy on edge device using Greengrass
+ 
+### Outputs
+
+The application publishes top-10 results on AWS IoT Cloud every second by default. For other output consumption options, please refer to Greengrass-FaaS-User-Guide.pdf
+
+### How it works
+
+Upon deployment,the sample application loads a network and an image to the Inference Engine plugin. When inference is done, the application publishes results to AWS IoT Cloud 
+
+=====================================================================================================
+
+# GreenGrass Object Detection Sample SSD
+
+This topic demonstrates how to run the GreenGrass Object Detection SSD sample application, which does inference using object detection networks like Squeezenet-SSD on Intel® Processors, Intel® HD Graphics and Intel® FPGA.
+
+## Running
+
+1. Modify the "accelerator" parameter inside the sample to deploy the sample on any accelerator option of your choice(CPU/GPU/FPGA)  
+   For CPU, please specify "CPU"  
+   For GPU, please specify "GPU"  
+   For FPGA, please specify "HETERO:FPGA,CPU"  
+2. Enable the option(s) on how output is displayed/consumed 
+3. Set the variable is_async_mode to 'True' for Asynchronous execution and 'False' for Synchronous execution
+3. Now follow the instructions listed in the Greengrass-FaaS-User-Guide.pdf to create the lambda and deploy on edge device using Greengrass
+ 
+### Outputs
+
+The application publishes detection outputs such as class label, class confidence, and bounding box coordinates on AWS IoT Cloud every second. For other output consumption options, please refer to Greengrass-FaaS-User-Guide.pdf  
+
+### How it works
+
+Upon deployment,the sample application loads a network and an image to the Inference Engine plugin. When inference is done, the application publishes results to AWS IoT Cloud 
+ 
+
+

inference-engine/ie_bridges/python/sample/greengrass_samples/greengrass_classification_sample.py

@@ -0,0 +1,176 @@
+"""
+BSD 3-clause "New" or "Revised" license
+
+Copyright (C) 2018 Intel Coporation.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import sys
+import os
+import cv2
+import numpy as np
+import greengrasssdk
+import boto3
+import timeit
+import datetime
+import json
+from collections import OrderedDict 
+
+from openvino.inference_engine import IENetwork, IEPlugin
+
+# Specify the delta in seconds between each report
+reporting_interval = 1.0
+
+# Parameters for IoT Cloud
+enable_iot_cloud_output = True
+
+# Parameters for Kinesis
+enable_kinesis_output = False
+kinesis_stream_name = ""
+kinesis_partition_key = ""
+kinesis_region = ""
+
+# Parameters for S3
+enable_s3_jpeg_output = False
+s3_bucket_name = ""
+
+# Parameters for jpeg output on local disk
+enable_local_jpeg_output = False
+
+# Create a Greengrass Core SDK client for publishing messages to AWS Cloud
+client = greengrasssdk.client("iot-data")
+
+# Create an S3 client for uploading files to S3
+if enable_s3_jpeg_output:
+    s3_client = boto3.client("s3")
+
+# Create a Kinesis client for putting records to streams
+if enable_kinesis_output:
+    kinesis_client = boto3.client("kinesis", "us-west-2")
+
+# Read environment variables set by Lambda function configuration
+PARAM_MODEL_XML = os.environ.get("PARAM_MODEL_XML")
+PARAM_INPUT_SOURCE = os.environ.get("PARAM_INPUT_SOURCE")
+PARAM_DEVICE = os.environ.get("PARAM_DEVICE")
+PARAM_OUTPUT_DIRECTORY = os.environ.get("PARAM_OUTPUT_DIRECTORY")
+PARAM_CPU_EXTENSION_PATH = os.environ.get("PARAM_CPU_EXTENSION_PATH")
+PARAM_LABELMAP_FILE = os.environ.get("PARAM_LABELMAP_FILE")
+PARAM_TOPIC_NAME = os.environ.get("PARAM_TOPIC_NAME", "intel/faas/classification")
+PARAM_NUM_TOP_RESULTS = int(os.environ.get("PARAM_NUM_TOP_RESULTS", "10"))
+
+def report(res_json, frame):
+    now = datetime.datetime.now()
+    date_prefix = str(now).replace(" ", "_")
+    if enable_iot_cloud_output:
+        data = json.dumps(res_json)
+        client.publish(topic=PARAM_TOPIC_NAME, payload=data)
+    if enable_kinesis_output:
+        kinesis_client.put_record(StreamName=kinesis_stream_name, Data=json.dumps(res_json), PartitionKey=kinesis_partition_key)
+    if enable_s3_jpeg_output:
+        temp_image = os.path.join(PARAM_OUTPUT_DIRECTORY, "inference_result.jpeg")
+        cv2.imwrite(temp_image, frame)
+        with open(temp_image) as file:
+            image_contents = file.read()
+            s3_client.put_object(Body=image_contents, Bucket=s3_bucket_name, Key=date_prefix + ".jpeg") 
+    if enable_local_jpeg_output:
+        cv2.imwrite(os.path.join(PARAM_OUTPUT_DIRECTORY, date_prefix + ".jpeg"), frame)
+
+    
+def greengrass_classification_sample_run():
+    client.publish(topic=PARAM_TOPIC_NAME, payload="OpenVINO: Initializing...")
+    model_bin = os.path.splitext(PARAM_MODEL_XML)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=PARAM_DEVICE, plugin_dirs="")
+    if "CPU" in PARAM_DEVICE:
+        plugin.add_cpu_extension(PARAM_CPU_EXTENSION_PATH)
+    # Read IR
+    net = IENetwork.from_ir(model=PARAM_MODEL_XML, weights=model_bin)
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    # Read and pre-process input image
+    n, c, h, w = net.inputs[input_blob]
+    cap = cv2.VideoCapture(PARAM_INPUT_SOURCE)
+    exec_net = plugin.load(network=net)
+    del net
+    client.publish(topic=PARAM_TOPIC_NAME, payload="Starting inference on %s" % PARAM_INPUT_SOURCE)
+    start_time = timeit.default_timer()
+    inf_seconds = 0.0
+    frame_count = 0
+    res_json = []
+    labeldata = None
+    if PARAM_LABELMAP_FILE is not None:
+       with open(PARAM_LABELMAP_FILE) as labelmap_file:
+            labeldata = json.load(labelmap_file)
+    
+    while (cap.isOpened()):
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frameid = cap.get(cv2.CAP_PROP_POS_FRAMES)
+        initial_w = cap.get(3)
+        initial_h = cap.get(4)
+        in_frame = cv2.resize(frame, (w, h))
+        in_frame = in_frame.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        in_frame = in_frame.reshape((n, c, h, w))
+        # Start synchronous inference
+        inf_start_time = timeit.default_timer()
+        res = exec_net.infer(inputs={input_blob: in_frame})
+        inf_seconds += timeit.default_timer() - inf_start_time
+        top_ind = np.argsort(res[out_blob], axis=1)[0, -PARAM_NUM_TOP_RESULTS:][::-1]
+        # Parse detection results of the current request
+        res_json = OrderedDict()
+        res_json["Candidates"] = OrderedDict()
+        frame_timestamp = datetime.datetime.now()
+            
+        for i in top_ind:
+            classlabel = labeldata[str(i)] if labeldata else str(i)
+            res_json["Candidates"][classlabel] = round(res[out_blob][0, i], 2)
+            
+        frame_count += 1
+        # Measure elapsed seconds since the last report
+        seconds_elapsed = timeit.default_timer() - start_time
+        if seconds_elapsed >= reporting_interval:
+            res_json["timestamp"] = frame_timestamp.isoformat()
+            res_json["frame_id"] = int(frameid)   
+            res_json["inference_fps"] = frame_count / inf_seconds
+            start_time = timeit.default_timer()
+            report(res_json, frame)
+            frame_count = 0
+            inf_seconds = 0.0
+
+    client.publish(topic=PARAM_TOPIC_NAME, payload="End of the input, exiting...")
+    del exec_net
+    del plugin
+
+greengrass_classification_sample_run()
+
+def function_handler(event, context):
+    client.publish(topic=PARAM_TOPIC_NAME, payload='HANDLER_CALLED!')
+    return

inference-engine/ie_bridges/python/sample/greengrass_samples/greengrass_object_detection_sample_ssd.py

@@ -0,0 +1,179 @@
+"""
+BSD 3-clause "New" or "Revised" license
+
+Copyright (C) 2018 Intel Coporation.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import sys
+import os
+import cv2
+import numpy as np
+import greengrasssdk
+import boto3
+import timeit
+import datetime
+import json
+from collections import OrderedDict 
+
+from openvino.inference_engine import IENetwork, IEPlugin
+
+# Specify the delta in seconds between each report
+reporting_interval = 1.0
+
+# Parameters for IoT Cloud
+enable_iot_cloud_output = True
+
+# Parameters for Kinesis
+enable_kinesis_output = False
+kinesis_stream_name = ""
+kinesis_partition_key = ""
+kinesis_region = ""
+
+# Parameters for S3
+enable_s3_jpeg_output = False
+s3_bucket_name = "ssd_test"
+
+# Parameters for jpeg output on local disk
+enable_local_jpeg_output = False
+
+# Create a Greengrass Core SDK client for publishing messages to AWS Cloud
+client = greengrasssdk.client("iot-data")
+
+# Create an S3 client for uploading files to S3
+if enable_s3_jpeg_output:
+    s3_client = boto3.client("s3")
+
+# Create a Kinesis client for putting records to streams
+if enable_kinesis_output:
+    kinesis_client = boto3.client("kinesis", "us-west-2")
+
+# Read environment variables set by Lambda function configuration
+PARAM_MODEL_XML = os.environ.get("PARAM_MODEL_XML")
+PARAM_INPUT_SOURCE = os.environ.get("PARAM_INPUT_SOURCE")
+PARAM_DEVICE = os.environ.get("PARAM_DEVICE")
+PARAM_OUTPUT_DIRECTORY = os.environ.get("PARAM_OUTPUT_DIRECTORY")
+PARAM_CPU_EXTENSION_PATH = os.environ.get("PARAM_CPU_EXTENSION_PATH")
+PARAM_LABELMAP_FILE = os.environ.get("PARAM_LABELMAP_FILE")
+PARAM_TOPIC_NAME = os.environ.get("PARAM_TOPIC_NAME", "intel/faas/ssd")
+
+def report(res_json, frame):
+    now = datetime.datetime.now()
+    date_prefix = str(now).replace(" ", "_")
+    if enable_iot_cloud_output:
+        data = json.dumps(res_json)
+        client.publish(topic=PARAM_TOPIC_NAME, payload=data)
+    if enable_kinesis_output:
+        kinesis_client.put_record(StreamName=kinesis_stream_name, Data=json.dumps(res_json), PartitionKey=kinesis_partition_key)
+    if enable_s3_jpeg_output:
+        temp_image = os.path.join(PARAM_OUTPUT_DIRECTORY, "inference_result.jpeg")
+        cv2.imwrite(temp_image, frame)
+        with open(temp_image) as file:
+            image_contents = file.read()
+            s3_client.put_object(Body=image_contents, Bucket=s3_bucket_name, Key=date_prefix + ".jpeg") 
+    if enable_local_jpeg_output:
+        cv2.imwrite(os.path.join(PARAM_OUTPUT_DIRECTORY, date_prefix + ".jpeg"), frame)
+
+    
+def greengrass_object_detection_sample_ssd_run():
+    client.publish(topic=PARAM_TOPIC_NAME, payload="OpenVINO: Initializing...")
+    model_bin = os.path.splitext(PARAM_MODEL_XML)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=PARAM_DEVICE, plugin_dirs="")
+    if "CPU" in PARAM_DEVICE:
+        plugin.add_cpu_extension(PARAM_CPU_EXTENSION_PATH)
+    # Read IR
+    net = IENetwork.from_ir(model=PARAM_MODEL_XML, weights=model_bin)
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    # Read and pre-process input image
+    n, c, h, w = net.inputs[input_blob]
+    cap = cv2.VideoCapture(PARAM_INPUT_SOURCE)
+    exec_net = plugin.load(network=net)
+    del net
+    client.publish(topic=PARAM_TOPIC_NAME, payload="Starting inference on %s" % PARAM_INPUT_SOURCE)
+    start_time = timeit.default_timer()
+    inf_seconds = 0.0
+    frame_count = 0
+    labeldata = None
+    if PARAM_LABELMAP_FILE is not None:
+       with open(PARAM_LABELMAP_FILE) as labelmap_file:
+            labeldata = json.load(labelmap_file)
+    
+    while (cap.isOpened()):
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frameid = cap.get(cv2.CAP_PROP_POS_FRAMES)
+        initial_w = cap.get(3)
+        initial_h = cap.get(4)
+        in_frame = cv2.resize(frame, (w, h))
+        in_frame = in_frame.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        in_frame = in_frame.reshape((n, c, h, w))
+        # Start synchronous inference
+        inf_start_time = timeit.default_timer()
+        res = exec_net.infer(inputs={input_blob: in_frame})
+        inf_seconds += timeit.default_timer() - inf_start_time
+        # Parse detection results of the current request
+        res_json = OrderedDict() 
+        frame_timestamp = datetime.datetime.now()    
+        object_id = 0
+        for obj in res[out_blob][0][0]:
+             if obj[2] > 0.5:
+                 xmin = int(obj[3] * initial_w)
+                 ymin = int(obj[4] * initial_h)
+                 xmax = int(obj[5] * initial_w)
+                 ymax = int(obj[6] * initial_h)
+                 cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), (255, 165, 20), 4)
+                 obj_id = "Object" + str(object_id)
+                 classlabel = labeldata[str(int(obj[1]))] if labeldata else ""
+                 res_json[obj_id] = {"label": int(obj[1]), "class": classlabel, "confidence": round(obj[2], 2), "xmin": round(obj[3], 2), "ymin": round(obj[4], 2), "xmax": round(obj[5], 2), "ymax": round(obj[6], 2)}
+                 object_id += 1
+        frame_count += 1
+        # Measure elapsed seconds since the last report
+        seconds_elapsed = timeit.default_timer() - start_time
+        if seconds_elapsed >= reporting_interval:
+            res_json["timestamp"] = frame_timestamp.isoformat()
+            res_json["frame_id"] = int(frameid)   
+            res_json["inference_fps"] = frame_count / inf_seconds
+            start_time = timeit.default_timer()
+            report(res_json, frame)
+            frame_count = 0
+            inf_seconds = 0.0
+
+    client.publish(topic=PARAM_TOPIC_NAME, payload="End of the input, exiting...")
+    del exec_net
+    del plugin
+
+greengrass_object_detection_sample_ssd_run()
+
+def function_handler(event, context):
+    client.publish(topic=PARAM_TOPIC_NAME, payload='HANDLER_CALLED!')
+    return

inference-engine/ie_bridges/python/sample/object_detection_demo_ssd_async.py

@@ -0,0 +1,176 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import time
+import logging as log
+from openvino.inference_engine import IENetwork, IEPlugin
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input",
+                        help="Path to video file or image. 'cam' for capturing video stream from camera", required=True,
+                        type=str)
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample "
+                             "will look for a suitable plugin for device specified (CPU by default)", default="CPU",
+                        type=str)
+    parser.add_argument("--labels", help="Labels mapping file", default=None, type=str)
+    parser.add_argument("-pt", "--prob_threshold", help="Probability threshold for detections filtering",
+                        default=0.5, type=float)
+
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+    # Plugin initialization for specified device and load extensions library if specified
+    log.info("Initializing plugin for {} device...".format(args.device))
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+
+    # Read IR
+    log.info("Reading IR...")
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    log.info("Loading IR to the plugin...")
+    exec_net = plugin.load(network=net, num_requests=2)
+    # Read and pre-process input image
+    n, c, h, w = net.inputs[input_blob]
+    del net
+    if args.input == 'cam':
+        input_stream = 0
+    else:
+        input_stream = args.input
+        assert os.path.isfile(args.input), "Specified input file doesn't exist"
+    if args.labels:
+        with open(args.labels, 'r') as f:
+            labels_map = [x.strip() for x in f]
+    else:
+        labels_map = None
+
+    cap = cv2.VideoCapture(input_stream)
+
+    cur_request_id = 0
+    next_request_id = 1
+
+    log.info("Starting inference in async mode...")
+    log.info("To switch between sync and async modes press Tab button")
+    log.info("To stop the sample execution press Esc button")
+    is_async_mode = True
+    render_time = 0
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            break
+        initial_w = cap.get(3)
+        initial_h = cap.get(4)
+        in_frame = cv2.resize(frame, (w, h))
+        in_frame = in_frame.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        in_frame = in_frame.reshape((n, c, h, w))
+
+        # Main sync point:
+        # in the truly Async mode we start the NEXT infer request, while waiting for the CURRENT to complete
+        # in the regular mode we start the CURRENT request and immediately wait for it's completion
+        inf_start = time.time()
+        if is_async_mode:
+            exec_net.start_async(request_id=next_request_id, inputs={input_blob: in_frame})
+        else:
+            exec_net.start_async(request_id=cur_request_id, inputs={input_blob: in_frame})
+        if exec_net.requests[cur_request_id].wait(-1) == 0:
+            inf_end = time.time()
+            det_time = inf_end - inf_start
+
+            # Parse detection results of the current request
+            res = exec_net.requests[cur_request_id].outputs[out_blob]
+            for obj in res[0][0]:
+                # Draw only objects when probability more than specified threshold
+                if obj[2] > args.prob_threshold:
+                    xmin = int(obj[3] * initial_w)
+                    ymin = int(obj[4] * initial_h)
+                    xmax = int(obj[5] * initial_w)
+                    ymax = int(obj[6] * initial_h)
+                    class_id = int(obj[1])
+                    # Draw box and label\class_id
+                    color = (min(class_id * 12.5, 255), min(class_id * 7, 255), min(class_id * 5, 255))
+                    cv2.rectangle(frame, (xmin, ymin), (xmax, ymax), color, 2)
+                    det_label = labels_map[class_id] if labels_map else str(class_id)
+                    cv2.putText(frame, det_label + ' ' + str(round(obj[2] * 100, 1)) + ' %', (xmin, ymin - 7),
+                                cv2.FONT_HERSHEY_COMPLEX, 0.6, color, 1)
+
+            # Draw performance stats
+            inf_time_message = "Inference time: N\A for async mode" if is_async_mode else \
+                "Inference time: {:.3f} ms".format(det_time * 1000)
+            render_time_message = "OpenCV rendering time: {:.3f} ms".format(render_time * 1000)
+            async_mode_message = "Async mode is on. Processing request {}".format(cur_request_id) if is_async_mode else \
+                "Async mode is off. Processing request {}".format(cur_request_id)
+
+            cv2.putText(frame, inf_time_message, (15, 15), cv2.FONT_HERSHEY_COMPLEX, 0.5, (200, 10, 10), 1)
+            cv2.putText(frame, render_time_message, (15, 30), cv2.FONT_HERSHEY_COMPLEX, 0.5, (10, 10, 200), 1)
+            cv2.putText(frame, async_mode_message, (10, int(initial_h - 20)), cv2.FONT_HERSHEY_COMPLEX, 0.5,
+                        (10, 10, 200), 1)
+
+        #
+        render_start = time.time()
+        cv2.imshow("Detection Results", frame)
+        render_end = time.time()
+        render_time = render_end - render_start
+
+        key = cv2.waitKey(1)
+        if key == 27:
+            break
+        if (9 == key):
+            is_async_mode = not is_async_mode
+            log.info("Switched to {} mode".format("async" if is_async_mode else "sync"))
+
+        if is_async_mode:
+            cur_request_id, next_request_id = next_request_id, cur_request_id
+
+    cv2.destroyAllWindows()
+    del exec_net
+    del plugin
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/requirements.txt

@@ -0,0 +1,2 @@
+opencv-python
+numpy

inference-engine/ie_bridges/python/sample/segmentation_sample.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+import logging as log
+from time import time
+from openvino.inference_engine import IENetwork, IEPlugin
+
+classes_color_map = [
+    (150, 150, 150),
+    (58, 55, 169),
+    (211, 51, 17),
+    (157, 80, 44),
+    (23, 95, 189),
+    (210, 133, 34),
+    (76, 226, 202),
+    (101, 138, 127),
+    (223, 91, 182),
+    (80, 128, 113),
+    (235, 155, 55),
+    (44, 151, 243),
+    (159, 80, 170),
+    (239, 208, 44),
+    (128, 50, 51),
+    (82, 141, 193),
+    (9, 107, 10),
+    (223, 90, 142),
+    (50, 248, 83),
+    (178, 101, 130),
+    (71, 30, 204)
+]
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input", help="Path to a folder with images or path to an image files", required=True,
+                        type=str, nargs="+")
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample "
+                             "will look for a suitable plugin for device specified (CPU by default)", default="CPU",
+                        type=str)
+    parser.add_argument("-nt", "--number_top", help="Number of top results", default=10, type=int)
+    parser.add_argument("-ni", "--number_iter", help="Number of inference iterations", default=1, type=int)
+    parser.add_argument("-pc", "--perf_counts", help="Report performance counters", default=False, action="store_true")
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+    # Read IR
+    log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+
+    log.info("Preparing input blobs")
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    net.batch_size = len(args.input)
+
+    # Read and pre-process input images
+    n, c, h, w = net.inputs[input_blob]
+    images = np.ndarray(shape=(n, c, h, w))
+    for i in range(n):
+        image = cv2.imread(args.input[i])
+        if image.shape[:-1] != (h, w):
+            log.warning("Image {} is resized from {} to {}".format(args.input[i], image.shape[:-1], (h, w)))
+            image = cv2.resize(image, (w, h))
+        image = image.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        images[i] = image
+    log.info("Batch size is {}".format(n))
+
+    # Loading model to the plugin
+    log.info("Loading model to the plugin")
+    exec_net = plugin.load(network=net)
+    del net
+
+    # Start sync inference
+    log.info("Starting inference ({} iterations)".format(args.number_iter))
+    infer_time = []
+    for i in range(args.number_iter):
+        t0 = time()
+        res = exec_net.infer(inputs={input_blob: images})
+        infer_time.append((time() - t0) * 1000)
+    log.info("Average running time of one iteration: {} ms".format(np.average(np.asarray(infer_time))))
+    if args.perf_counts:
+        perf_counts = exec_net.requests[0].get_perf_counts()
+        log.info("Performance counters:")
+        print("{:<70} {:<15} {:<15} {:<15} {:<10}".format('name', 'layer_type', 'exet_type', 'status', 'real_time, us'))
+        for layer, stats in perf_counts.items():
+            print ("{:<70} {:<15} {:<15} {:<15} {:<10}".format(layer, stats['layer_type'], stats['exec_type'],
+                                                               stats['status'], stats['real_time']))
+    # Processing output blob
+    log.info("Processing output blob")
+    res = res[out_blob]
+    for batch, data in enumerate(res):
+        classes_map = np.zeros(shape=(h, w, c), dtype=np.int)
+        for i in range(h):
+            for j in range(w):
+                if len(data[:, i, j]) == 1:
+                    pixel_class = int(data[:, i, j])
+                else:
+                    pixel_class = np.argmax(data[:, i, j])
+                classes_map[i, j, :] = classes_color_map[min(pixel_class, 20)]
+        out_img = os.path.join(os.path.dirname(__file__), "out_{}.bmp".format(batch))
+        cv2.imwrite(out_img, classes_map)
+        log.info("Result image was saved to {}".format(out_img))
+    del exec_net
+    del plugin
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/style_transfer_sample.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python
+"""
+ Copyright (c) 2018 Intel Corporation
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+"""
+from __future__ import print_function
+import sys
+import os
+from argparse import ArgumentParser
+import cv2
+import numpy as np
+import logging as log
+from time import time
+from openvino.inference_engine import IENetwork, IEPlugin
+
+
+def build_argparser():
+    parser = ArgumentParser()
+    parser.add_argument("-m", "--model", help="Path to an .xml file with a trained model.", required=True, type=str)
+    parser.add_argument("-i", "--input", help="Path to a folder with images or path to an image files", required=True,
+                        type=str, nargs="+")
+    parser.add_argument("-l", "--cpu_extension",
+                        help="MKLDNN (CPU)-targeted custom layers.Absolute path to a shared library with the kernels "
+                             "impl.", type=str, default=None)
+    parser.add_argument("-pp", "--plugin_dir", help="Path to a plugin folder", type=str, default=None)
+    parser.add_argument("-d", "--device",
+                        help="Specify the target device to infer on; CPU, GPU, FPGA or MYRIAD is acceptable. Sample "
+                             "will look for a suitable plugin for device specified (CPU by default)", default="CPU",
+                        type=str)
+    parser.add_argument("-nt", "--number_top", help="Number of top results", default=10, type=int)
+    parser.add_argument("-ni", "--number_iter", help="Number of inference iterations", default=1, type=int)
+    parser.add_argument("--mean_val_r", "-mean_val_r",
+                        help="Mean value of red chanel for mean value subtraction in postprocessing ", default=0,
+                        type=float)
+    parser.add_argument("--mean_val_g", "-mean_val_g",
+                        help="Mean value of green chanel for mean value subtraction in postprocessing ", default=0,
+                        type=float)
+    parser.add_argument("--mean_val_b", "-mean_val_b",
+                        help="Mean value of blue chanel for mean value subtraction in postprocessing ", default=0,
+                        type=float)
+    parser.add_argument("-pc", "--perf_counts", help="Report performance counters", default=False, action="store_true")
+
+
+    return parser
+
+
+def main():
+    log.basicConfig(format="[ %(levelname)s ] %(message)s", level=log.INFO, stream=sys.stdout)
+    args = build_argparser().parse_args()
+    model_xml = args.model
+    model_bin = os.path.splitext(model_xml)[0] + ".bin"
+
+    # Plugin initialization for specified device and load extensions library if specified
+    plugin = IEPlugin(device=args.device, plugin_dirs=args.plugin_dir)
+    if args.cpu_extension and 'CPU' in args.device:
+        plugin.add_cpu_extension(args.cpu_extension)
+    # Read IR
+    log.info("Loading network files:\n\t{}\n\t{}".format(model_xml, model_bin))
+    net = IENetwork.from_ir(model=model_xml, weights=model_bin)
+
+    if "CPU" in plugin.device:
+        supported_layers = plugin.get_supported_layers(net)
+        not_supported_layers = [l for l in net.layers.keys() if l not in supported_layers]
+        if len(not_supported_layers) != 0:
+            log.error("Following layers are not supported by the plugin for specified device {}:\n {}".
+                      format(plugin.device, ', '.join(not_supported_layers)))
+            log.error("Please try to specify cpu extensions library path in sample's command line parameters using -l "
+                      "or --cpu_extension command line argument")
+            sys.exit(1)
+
+    assert len(net.inputs.keys()) == 1, "Sample supports only single input topologies"
+    assert len(net.outputs) == 1, "Sample supports only single output topologies"
+
+    log.info("Preparing input blobs")
+    input_blob = next(iter(net.inputs))
+    out_blob = next(iter(net.outputs))
+    net.batch_size = len(args.input)
+
+    # Read and pre-process input images
+    n, c, h, w = net.inputs[input_blob]
+    images = np.ndarray(shape=(n, c, h, w))
+    for i in range(n):
+        image = cv2.imread(args.input[i])
+        if image.shape[:-1] != (h, w):
+            log.warning("Image {} is resized from {} to {}".format(args.input[i], image.shape[:-1], (h, w)))
+            image = cv2.resize(image, (w, h))
+        image = image.transpose((2, 0, 1))  # Change data layout from HWC to CHW
+        images[i] = image
+    log.info("Batch size is {}".format(n))
+
+    # Loading model to the plugin
+    log.info("Loading model to the plugin")
+    exec_net = plugin.load(network=net)
+    del net
+
+    # Start sync inference
+    log.info("Starting inference ({} iterations)".format(args.number_iter))
+    infer_time = []
+    for i in range(args.number_iter):
+        t0 = time()
+        res = exec_net.infer(inputs={input_blob: images})
+        infer_time.append((time() - t0) * 1000)
+    log.info("Average running time of one iteration: {} ms".format(np.average(np.asarray(infer_time))))
+    if args.perf_counts:
+        perf_counts = exec_net.requests[0].get_perf_counts()
+        log.info("Performance counters:")
+        print("{:<70} {:<15} {:<15} {:<15} {:<10}".format('name', 'layer_type', 'exet_type', 'status', 'real_time, us'))
+        for layer, stats in perf_counts.items():
+            print ("{:<70} {:<15} {:<15} {:<15} {:<10}".format(layer, stats['layer_type'], stats['exec_type'],
+                                                               stats['status'], stats['real_time']))
+    # Processing output blob
+    log.info("Processing output blob")
+    res = res[out_blob]
+    # Post process output
+    for batch, data in enumerate(res):
+        # Clip values to [0, 255] range
+        data = np.swapaxes(data, 0, 2)
+        data = np.swapaxes(data, 0, 1)
+        data = cv2.cvtColor(data, cv2.COLOR_BGR2RGB)
+        data[data < 0] = 0
+        data[data > 255] = 255
+        data = data[::] - (args.mean_val_r, args.mean_val_g, args.mean_val_b)
+        out_img = os.path.join(os.path.dirname(__file__), "out_{}.bmp".format(batch))
+        cv2.imwrite(out_img, data)
+        log.info("Result image was saved to {}".format(out_img))
+    del exec_net
+    del plugin
+
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)

inference-engine/ie_bridges/python/sample/voc_labels.txt

@@ -0,0 +1,21 @@
+background
+aeroplane
+bicycle
+bird
+boat
+bottle
+bus
+car
+cat
+chair
+cow
+diningtable
+dog
+horse
+motorbike
+person
+pottedplant
+sheep
+sofa
+train
+tvmonitor