Publishing R3

.coveragerc

@@ -0,0 +1,39 @@
+# .coveragerc to control coverage.py
+[run]
+branch = True
+
+source =
+    mo/
+    mo.py
+
+omit =
+    # omit anything in a .local directory anywhere
+    */.local/*
+    # omit everything in /usr
+    /usr/*
+    # omit tests
+    */test_*.py
+    # init scripts
+    */__init__.py
+
+[report]
+# Regexes for lines to exclude from consideration
+exclude_lines =
+    # Have to re-enable the standard pragma
+    pragma: no cover
+
+    # Don't complain about missing debug-only code:
+    def __repr__
+
+    # Don't complain if tests don't hit defensive assertion code:
+    raise AssertionError
+    raise NotImplementedError
+
+    # Don't complain if non-runnable code isn't run:
+    if 0:
+    if __name__ == .__main__.:
+
+ignore_errors = True
+
+[html]
+directory = htmlcov

.editorconfig

@@ -0,0 +1,21 @@
+root = true
+
+[*]
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+# 4 space indentation
+#[*.py]
+#indent_style = space
+#indent_size = 4
+
+#[{CMakeLists.txt,*.cmake}]
+#indent_style = space
+#indent_size = 4
+
+#[*.{c,cpp,h,hpp}]
+#indent_style = space
+#indent_size = 4

.gitattributes

@@ -0,0 +1,65 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+*.py text eol=lf
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

.gitignore

@@ -0,0 +1,343 @@
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+[Xx]64/
+[Xx]86/
+[Bb]uild/
+bld/
+[Bb]in/
+[Oo]bj/
+
+# PY.TEST
+*.pyc
+tests/integration/report.html
+tests/integration/report.xml
+tests/integration/assets/
+tests/integration/__pycache__/
+
+# Visual Studio 2015 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# DNX
+project.lock.json
+artifacts/
+
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+
+# TODO: Un-comment the next line if you do not want to checkin
+# your web deploy settings because they may include unencrypted
+# passwords
+#*.pubxml
+*.publishproj
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/packages/*
+# except build/, which is used as an MSBuild target.
+!**/packages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/packages/repositories.config
+# NuGet v3's project.json files produces more ignoreable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Microsoft Azure ApplicationInsights config file
+ApplicationInsights.config
+
+# Windows Store app package directory
+AppPackages/
+BundleArtifacts/
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+[Ss]tyle[Cc]op.*
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.pfx
+*.publishsettings
+node_modules/
+orleans.codegen.cs
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Target VS files:
+vsx64
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# LightSwitch generated files
+GeneratedArtifacts/
+ModelManifest.xml
+
+# Paket dependency manager
+.paket/paket.exe
+
+# FAKE - F# Make
+.fake/
+*.filters
+/External
+/Output
+/InferenceEngineMain/models
+/Test
+/HTTPClient/*.a
+/InferenceEngineMain/newModels
+.DS_Store
+
+# For IDEA
+.idea/
+VS/
+Xcode/
+temp/
+report/
+.kdev4/
+*.kdev4
+*.kate-swp
+
+/lin-build
+/win-build
+/CMakeFiles
+*.stamp
+*.depend
+*.vcxproj
+*.sln
+/CMakeCache.txt
+.vimprj/
+build_IA32/
+doc/
+.dir-locals.el
+GTAGS
+GPATH
+GRTAGS
+GSYMS
+compile_commands.json
+service/dot-net-service/Output
+**/sublime_build
+/.project
+.vscode/
+/vsx32
+/service/dot-net-service/.klocwork/DotNetService
+cmake-build-*/
+/lin64
+
+.gdb_history
+.local_vimrc
+.ycm_extra_conf.py
+tags
+
+
+# from Model Optimizer repo
+.idea
+.project
+.cproject
+.pydevproject
+.settings
+/bin/
+/gen/
+__pycache__
+*.swp
+/config.xml
+
+# Python-specific
+.env3
+*.pyc
+
+# Tests-specific
+.coverage
+htmlcov
+pylint_report.txt
+pylint_report_comments.txt
+
+# Documentation-generated
+docs/build
+docs/source/_static
+docs/source/_templates
+docs/source/generated/
+
+# Artifacts
+/*.bin
+/*.xml
+/*.json
+/*.so
+/*.txt
+/*.mapping
+/*.dat
+/*.svg

.pylintdict

@@ -0,0 +1,68 @@
+attrs
+arg
+args
+bfs
+bool
+caffe
+caffemodel
+ceil
+chw
+cli
+cls
+co-location
+concat
+config
+const
+conv
+dfs
+dict
+dsu
+eltwise
+enum
+env
+eq
+fallback
+fc
+fcn
+fw
+hardcoded
+http
+https
+hwc
+indices
+inplace
+inv
+io
+len
+lrn
+mul
+n-ary
+networkx
+ndarray
+nx
+np
+numpy
+org
+oi
+params
+pb
+pbs
+priorbox
+priorboxes
+proto
+protobuf
+protobufs
+prototxt
+regex
+reorgyolo
+regionyolo
+replacers
+resnet
+rcnn
+split
+splitv
+ssd
+usr
+undead
+xml
+www

.pylintrc

@@ -0,0 +1,410 @@
+[MASTER]
+
+# Specify a configuration file.
+#rcfile=
+
+# Python code to execute, usually for sys.path manipulation such as
+# pygtk.require().
+init-hook='sys.path.append(os.path.abspath(os.path.curdir))'
+
+# Add files or directories to the blacklist. They should be base names, not
+# paths.
+ignore=proto, tests, docs, automation
+
+# Add files or directories matching the regex patterns to the blacklist. The
+# regex matches against base names, not paths.
+ignore-patterns=.env3/*, python3.5, .*_test.py
+
+# Pickle collected data for later comparisons.
+persistent=yes
+
+# List of plugins (as comma separated values of python modules names) to load,
+# usually to register additional checkers.
+load-plugins=
+
+# Use multiple processes to speed up Pylint.
+# jobs=4
+
+# Allow loading of arbitrary C extensions. Extensions are imported into the
+# active Python interpreter and may run arbitrary code.
+unsafe-load-any-extension=no
+
+# A comma-separated list of package or module names from where C extensions may
+# be loaded. Extensions are loading into the active Python interpreter and may
+# run arbitrary code
+extension-pkg-whitelist=
+
+# Allow optimization of some AST trees. This will activate a peephole AST
+# optimizer, which will apply various small optimizations. For instance, it can
+# be used to obtain the result of joining multiple strings with the addition
+# operator. Joining a lot of strings can lead to a maximum recursion error in
+# Pylint and this flag can prevent that. It has one side effect, the resulting
+# AST will be different than the one from reality. This option is deprecated
+# and it will be removed in Pylint 2.0.
+optimize-ast=no
+
+[MESSAGES CONTROL]
+
+# Only show warnings with the listed confidence levels. Leave empty to show
+# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED
+confidence=
+
+# Enable the message, report, category or checker with the given id(s). You can
+# either give multiple identifier separated by comma (,) or put this option
+# multiple time (only on the command line, not in the configuration file where
+# it should appear only once). See also the "--disable" option for examples.
+#enable=
+
+# Disable the message, report, category or checker with the given id(s). You
+# can either give multiple identifiers separated by comma (,) or put this
+# option multiple times (only on the command line, not in the configuration
+# file where it should appear only once).You can also use "--disable=all" to
+# disable everything first and then reenable specific checks. For example, if
+# you want to run only the similarities checker, you can use "--disable=all
+# --enable=similarities". If you want to run only the classes checker, but have
+# no Warning level messages displayed, use"--disable=all --enable=classes
+# --disable=W"
+disable=locally-disabled,too-few-public-methods,no-self-use,too-many-ancestors,
+        missing-docstring,old-style-class,consider-iterating-dictionary,consider-using-enumerate,
+        superfluous-parens,no-else-return,duplicate-code,wrong-import-order,
+        too-many-locals,logging-not-lazy,unnecessary-lambda,super-on-old-class,ungrouped-imports,too-many-format-args,
+        protected-access,too-many-statements,too-many-branches,too-many-return-statements,too-many-public-methods,
+        super-init-not-called,singleton-comparison,pointless-string-statement,broad-except, invalid-name
+
+[REPORTS]
+
+# Set the output format. Available formats are text, parseable, colorized, msvs
+# (visual studio) and html. You can also give a reporter class, eg
+# mypackage.mymodule.MyReporterClass.
+output-format=text
+
+# Put messages in a separate file for each module / package specified on the
+# command line instead of printing them on stdout. Reports (if any) will be
+# written in a file name "pylint_global.[txt|html]". This option is deprecated
+# and it will be removed in Pylint 2.0.
+files-output=no
+
+# Tells whether to display a full report or only the messages
+reports=yes
+
+# Python expression which should return a note less than 10 (10 is the highest
+# note). You have access to the variables errors warning, statement which
+# respectively contain the number of errors / warnings messages and the total
+# number of statements analyzed. This is used by the global evaluation report
+# (RP0004).
+evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10)
+
+# Template used to display messages. This is a python new-style format string
+# used to format the message information. See doc for all details
+#msg-template=
+
+
+[LOGGING]
+
+# Logging modules to check that the string format arguments are in logging
+# function parameter format
+logging-modules=logging
+
+
+[SIMILARITIES]
+
+# Minimum lines number of a similarity.
+min-similarity-lines=8
+
+# Ignore comments when computing similarities.
+ignore-comments=yes
+
+# Ignore docstrings when computing similarities.
+ignore-docstrings=yes
+
+# Ignore imports when computing similarities.
+ignore-imports=no
+
+
+[FORMAT]
+
+# Maximum number of characters on a single line.
+max-line-length=120
+
+# Regexp for a line that is allowed to be longer than the limit.
+ignore-long-lines=^\s*(# )?<?https?://\S+>?$
+
+# Allow the body of an if to be on the same line as the test if there is no
+# else.
+single-line-if-stmt=no
+
+# List of optional constructs for which whitespace checking is disabled. `dict-
+# separator` is used to allow tabulation in dicts, etc.: {1  : 1,\n222: 2}.
+# `trailing-comma` allows a space between comma and closing bracket: (a, ).
+# `empty-line` allows space-only lines.
+no-space-check=trailing-comma,dict-separator
+
+# Maximum number of lines in a module
+max-module-lines=1000
+
+# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
+# tab).
+indent-string='    '
+
+# Number of spaces of indent required inside a hanging  or continued line.
+indent-after-paren=4
+
+# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
+expected-line-ending-format=
+
+
+[SPELLING]
+
+# Spelling dictionary name. Available dictionaries: none. To make it working
+# install python-enchant package.
+spelling-dict=en_US
+
+# List of comma separated words that should not be checked.
+spelling-ignore-words=TF, MO, IR, IE
+
+# A path to a file that contains private dictionary; one word per line.
+spelling-private-dict-file=.pylintdict
+
+# Tells whether to store unknown words to indicated private dictionary in
+# --spelling-private-dict-file option instead of raising a message.
+spelling-store-unknown-words=no
+
+
+[VARIABLES]
+
+# Tells whether we should check for unused import in __init__ files.
+init-import=no
+
+# A regular expression matching the name of dummy variables (i.e. expectedly
+# not used).
+dummy-variables-rgx=(_+[a-zA-Z0-9]*?$)|dummy
+
+# List of additional names supposed to be defined in builtins. Remember that
+# you should avoid to define new builtins when possible.
+additional-builtins=
+
+# List of strings which can identify a callback function by name. A callback
+# name must start or end with one of those strings.
+callbacks=cb_,_cb
+
+# List of qualified module names which can have objects that can redefine
+# builtins.
+redefining-builtins-modules=six.moves,future.builtins
+
+
+[TYPECHECK]
+
+# Tells whether missing members accessed in mixin class should be ignored. A
+# mixin class is detected if its name ends with "mixin" (case insensitive).
+ignore-mixin-members=yes
+
+# List of module names for which member attributes should not be checked
+# (useful for modules/projects where namespaces are manipulated during runtime
+# and thus existing member attributes cannot be deduced by static analysis. It
+# supports qualified module names, as well as Unix pattern matching.
+ignored-modules=flask_sqlalchemy,app.extensions.flask_sqlalchemy
+
+# List of class names for which member attributes should not be checked (useful
+# for classes with dynamically set attributes). This supports the use of
+# qualified names.
+ignored-classes=optparse.Values,thread._local,_thread._local
+
+# List of members which are set dynamically and missed by pylint inference
+# system, and so shouldn't trigger E1101 when accessed. Python regular
+# expressions are accepted.
+generated-members=fget,query,begin,add,merge,delete,commit,rollback
+
+# List of decorators that produce context managers, such as
+# contextlib.contextmanager. Add to this list to register other decorators that
+# produce valid context managers.
+contextmanager-decorators=contextlib.contextmanager
+
+
+[MISCELLANEOUS]
+
+# List of note tags to take in consideration, separated by a comma.
+notes=FIXME,XXX,TODO
+
+
+[BASIC]
+
+# Good variable names which should always be accepted, separated by a comma
+good-names=i,j,k,ex,Run,_,log,api,a,c,d,e,ei,f,hp,id,l,l2,ml,mn,n,N,op,p,pb,pb,ph,q,rt,s,s1,s2,si,u,v,wp,x,y
+
+# Bad variable names which should always be refused, separated by a comma
+bad-names=foo,bar,baz,toto,tutu,tata
+
+# Colon-delimited sets of names that determine each other's naming style when
+# the name regexes allow several styles.
+name-group=
+
+# Include a hint for the correct naming format with invalid-name
+include-naming-hint=no
+
+# List of decorators that produce properties, such as abc.abstractproperty. Add
+# to this list to register other decorators that produce valid properties.
+property-classes=abc.abstractproperty
+
+# Regular expression matching correct class names
+class-rgx=[A-Z_][a-zA-Z0-9]+$
+
+# Naming hint for class names
+class-name-hint=[A-Z_][a-zA-Z0-9]+$
+
+# Regular expression matching correct constant names
+const-rgx=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Naming hint for constant names
+const-name-hint=(([A-Z_][A-Z0-9_]*)|(__.*__))$
+
+# Regular expression matching correct argument names
+argument-rgx=([a-z_][a-z0-9_]{2,40}$)|(fileName)|(pl)|(t)
+
+# Naming hint for argument names
+argument-name-hint=[a-z_][a-z0-9_]{2,40}$
+
+# Regular expression matching correct inline iteration names
+inlinevar-rgx=[A-Za-z_][A-Za-z0-9_]*$
+
+# Naming hint for inline iteration names
+inlinevar-name-hint=[A-Za-z_][A-Za-z0-9_]*$
+
+# Regular expression matching correct method names
+method-rgx=[a-z_][a-z0-9_]{2,40}$
+
+# Naming hint for method names
+method-name-hint=[a-z_][a-z0-9_]{2,40}$
+
+# Regular expression matching correct function names
+function-rgx=([a-z_][a-z0-9_]{2,40}$)
+
+# Naming hint for function names
+function-name-hint=[a-z_][a-z0-9_]{2,40}$
+
+# Regular expression matching correct class attribute names
+class-attribute-rgx=([A-Za-z_][A-Za-z0-9_]{2,40}|(__.*__))$
+
+# Naming hint for class attribute names
+class-attribute-name-hint=([A-Za-z_][A-Za-z0-9_]{2,40}|(__.*__))$
+
+# Regular expression matching correct attribute names
+attr-rgx=[a-z_][a-z0-9_]{2,40}$
+
+# Naming hint for attribute names
+attr-name-hint=[a-z_][a-z0-9_]{2,40}$
+
+# Regular expression matching correct variable names
+variable-rgx=[a-z_][a-z0-9_]{2,40}$
+
+# Naming hint for variable names
+variable-name-hint=[a-z_][a-z0-9_]{2,40}$
+
+# Regular expression matching correct module names
+module-rgx=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Naming hint for module names
+module-name-hint=(([a-z_][a-z0-9_]*)|([A-Z][a-zA-Z0-9]+))$
+
+# Regular expression which should only match function or class names that do
+# not require a docstring.
+no-docstring-rgx=^_
+
+# Minimum line length for functions/classes that require docstrings, shorter
+# ones are exempt.
+docstring-min-length=5
+
+
+[ELIF]
+
+# Maximum number of nested blocks for function / method body
+max-nested-blocks=5
+
+
+[DESIGN]
+
+# Maximum number of arguments for function / method
+max-args=5
+
+# Argument names that match this expression will be ignored. Default to name
+# with leading underscore
+ignored-argument-names=_.*
+
+# Maximum number of locals for function / method body
+max-locals=15
+
+# Maximum number of return / yield for function / method body
+max-returns=6
+
+# Maximum number of branch for function / method body
+max-branches=12
+
+# Maximum number of statements in function / method body
+max-statements=50
+
+# Maximum number of parents for a class (see R0901).
+max-parents=10
+
+# Maximum number of attributes for a class (see R0902).
+max-attributes=7
+
+# Minimum number of public methods for a class (see R0903).
+min-public-methods=2
+
+# Maximum number of public methods for a class (see R0904).
+max-public-methods=20
+
+# Maximum number of boolean expressions in a if statement
+max-bool-expr=5
+
+
+[IMPORTS]
+
+# Deprecated modules which should not be used, separated by a comma
+deprecated-modules=optparse
+
+# Create a graph of every (i.e. internal and external) dependencies in the
+# given file (report RP0402 must not be disabled)
+import-graph=
+
+# Create a graph of external dependencies in the given file (report RP0402 must
+# not be disabled)
+ext-import-graph=
+
+# Create a graph of internal dependencies in the given file (report RP0402 must
+# not be disabled)
+int-import-graph=
+
+# Force import order to recognize a module as part of the standard
+# compatibility libraries.
+known-standard-library=
+
+# Force import order to recognize a module as part of a third party library.
+known-third-party=flask_restplus_patched
+
+# Analyse import fallback blocks. This can be used to support both Python 2 and
+# 3 compatible code, which means that the block might have code that exists
+# only in one or another interpreter, leading to false positives when analysed.
+analyse-fallback-blocks=no
+
+
+[CLASSES]
+
+# List of method names used to declare (i.e. assign) instance attributes.
+defining-attr-methods=__init__,__new__,setUp
+
+# List of valid names for the first argument in a class method.
+valid-classmethod-first-arg=cls
+
+# List of valid names for the first argument in a metaclass class method.
+valid-metaclass-classmethod-first-arg=mcs
+
+# List of member names, which should be excluded from the protected access
+# warning.
+exclude-protected=_asdict,_fields,_replace,_source,_make
+
+
+[EXCEPTIONS]
+
+# Exceptions that will emit a warning when being caught. Defaults to
+# "Exception"
+overgeneral-exceptions=Exception

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 [yyyy] [name of copyright owner]
+
+   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.

README.md

@@ -1,7 +1,37 @@
 # [OpenVINO™ Toolkit](https://01.org/openvinotoolkit) - Deep Learning Deployment Toolkit repository
+[![Stable release](https://img.shields.io/badge/version-2018.R3-green.svg)](https://github.com/opencv/dldt/releases/tag/2018_R3)
 [![Apache License Version 2.0](https://img.shields.io/badge/license-Apache_2.0-green.svg)](LICENSE)
 
-The master branch will be available as soon as the Continuous Integration system is configured. 
+This toolkit allows developers to deploy pre-trained deep learning models through a high-level C++ Inference Engine API integrated with application logic. 
+
+This open source version includes two components, namely Model Optimizer and Inference Engine, as well as CPU, GPU and heterogeneous plugins to accelerate deep learning inferencing on Intel(R) CPUs and Intel(R) Processor Graphics. It supports pre-trained models from the [Open Model Zoo](https://github.com/opencv/open_model_zoo/) along with 100+ open source and public models in popular formats such as Caffe*, Tensorflow*, MXNet* and ONNX*. 
+
+## Repository components:
+* [Inference Engine](https://software.intel.com/en-us/articles/OpenVINO-InferEngine)
+* [Model Optimizer](https://software.intel.com/en-us/articles/OpenVINO-ModelOptimizer)
+
+## License
+Deep Learning Deployment Toolkit is licensed under [Apache License Version 2.0](LICENSE).
+
+## Documentation
+* [OpenVINO™ Release Notes](https://software.intel.com/en-us/articles/OpenVINO-RelNotes)
+* Inference Engine [build instructions](inference-engine/README.md)
+
+## How to Contribute
+We welcome community contributions to the Deep Learning Deployment Toolkit repository. If you have an idea how to improve the product, please share it with us doing the following steps:
+* Make sure you can build the product and run all tests and samples with your patch
+* In case of a larger feature, provide a relevant unit tests and sample
+* Submit a pull request at https://github.com/opencv/dldt/pulls
+
+We will review your contribution and, if any additional fixes or modifications are necessary, may give some feedback to guide you. When accepted, your pull request will be merged into GitHub* repositories.
+
+Deep Learning Deployment Toolkit is licensed under Apache License, Version 2.0. By contributing to the project, you agree to the license and copyright terms therein and release your contribution under these terms.
+
+## Support
+Please report questions, issues and suggestions using:
+* [\#dldt](https://stackoverflow.com/search?q=%23dldt) tag on StackOverflow*
+* [GitHub* Issues](https://github.com/opencv/dldt/issues) 
+* [Forum](https://software.intel.com/en-us/forums/computer-vision)
 
 ---
-\* Other names and brands may be claimed as the property of others.
+\* Other names and brands may be claimed as the property of others.

inference-engine/CMakeLists.txt

@@ -0,0 +1,136 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+cmake_minimum_required (VERSION 3.3)
+
+project(InferenceEngine)
+
+set(DEV_BUILD TRUE)
+
+## WA for problem with gtest submodule. It cannot detect uint32 type.
+## remove Gtest submodule and this two lines together
+include (CheckTypeSize)
+check_type_size (uint32_t uint32_t LANGUAGE CXX)
+
+if (UNIX AND NOT APPLE)
+set(LINUX TRUE)
+endif()
+
+option (OS_FOLDER "create OS dedicated folder in output" OFF)
+
+if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    set (ARCH_FOLDER intel64)
+else()
+    set (ARCH_FOLDER  ia32)
+endif()
+
+if (OS_FOLDER)
+	message ("**** OS FOLDER IS: [${OS_FOLDER}]")
+	if ("${OS_FOLDER}" STREQUAL "ON")
+		message ("**** USING OS FOLDER: [${CMAKE_SYSTEM_NAME}]")
+		set (BIN_FOLDER bin/${CMAKE_SYSTEM_NAME}/${ARCH_FOLDER})
+	else()
+		set (BIN_FOLDER bin/${OS_FOLDER}/${ARCH_FOLDER})
+	endif()
+else()
+    set (BIN_FOLDER bin/${ARCH_FOLDER})
+endif()
+
+set (IE_MAIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set (CMAKE_MODULE_PATH "${IE_MAIN_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
+
+#printing debug messages
+include (debug)
+
+if("${CMAKE_BUILD_TYPE}" STREQUAL "")
+    debug_message(STATUS "CMAKE_BUILD_TYPE not defined, 'Release' will be used")
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+
+message(STATUS "BUILD_CONFIGURATION: ${CMAKE_BUILD_TYPE}")
+
+if(COVERAGE)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0")
+endif()
+
+if (UNIX)
+    SET(LIB_DL ${CMAKE_DL_LIBS})
+else()
+endif()
+
+set (OUTPUT_ROOT ${IE_MAIN_SOURCE_DIR})
+
+if(NOT(UNIX))
+	if (WIN32)
+		#set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MT")
+		#set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MTd")
+	endif()
+
+    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (CMAKE_LIBRARY_PATH ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER})
+    set (LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_DIRECTORY}) # compatibility issue: linux uses LIBRARY_OUTPUT_PATH, windows uses LIBRARY_OUTPUT_DIRECTORY
+else ()
+    set (CMAKE_LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    set (CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    set (CMAKE_COMPILE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+    set (CMAKE_PDB_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+    set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE})
+    set (LIBRARY_OUTPUT_DIRECTORY ${OUTPUT_ROOT}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    set (LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_DIRECTORY}/lib)
+endif()
+
+include(os_flags)
+
+#resolving rependencies for the project
+include (dependencies)
+
+if (APPLE)
+    set(CMAKE_MACOSX_RPATH 1)
+endif(APPLE)
+
+#rpath fully disabled
+if (NOT ENABLE_PLUGIN_RPATH)
+    SET (CMAKE_SKIP_RPATH TRUE)
+endif()
+
+#Use solution folders.
+set_property(GLOBAL PROPERTY USE_FOLDERS ON)
+#message("=====================> ${CMAKE_BUILD_TYPE} <=====================")
+
+message (STATUS "PROJECT ............................... " ${PROJECT_NAME})
+message (STATUS "CMAKE_BINARY_DIR ...................... " ${CMAKE_BINARY_DIR})
+message (STATUS "IE_MAIN_SOURCE_DIR .................... " ${IE_MAIN_SOURCE_DIR})
+message (STATUS "CMAKE_GENERATOR ....................... " ${CMAKE_GENERATOR})
+message (STATUS "CMAKE_C_COMPILER_ID ................... " ${CMAKE_C_COMPILER_ID})
+
+if("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
+    include(sdl)
+endif()
+set (CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+include (sanitizer)
+
+include(CheckCXXCompilerFlag)
+if(UNIX)
+    CHECK_CXX_COMPILER_FLAG("-fvisibility=hidden" COMPILER_SUPPORTS_VISIBILITY)
+    if (COMPILER_SUPPORTS_VISIBILITY)
+        #add_definitions(-fvisibility=hidden) todo: should be hidden? if so define default visibiliti explicite for each funtion
+        add_definitions(-fvisibility=default)
+    endif(COMPILER_SUPPORTS_VISIBILITY)
+endif(UNIX)
+
+add_subdirectory(src)
+add_subdirectory(tests)
+add_subdirectory(thirdparty)
+if (ENABLE_SAMPLES_CORE)
+    set(InferenceEngine_DIR "${CMAKE_BINARY_DIR}")
+
+    #to be able to link
+    set (LIB_FOLDER ${IE_MAIN_SOURCE_DIR}/${BIN_FOLDER}/${CMAKE_BUILD_TYPE}/lib)
+    add_subdirectory(samples)
+endif()

inference-engine/README.md

@@ -0,0 +1,63 @@
+## Build on Linux\* Systems
+
+The software was validated on:
+- Ubuntu\* 16.04 with default GCC\* 5.4.0
+- CentOS\* 7.4 with default GCC\* 4.8.5 (using clDNN library built separately with GCC\* 5.2)
+- [Intel® Graphics Compute Runtime for OpenCL™ Driver package 18.28.11080](https://github.com/intel/compute-runtime/releases/tag/18.28.11080).
+
+### Software Requirements
+- [CMake\*](https://cmake.org/download/) 3.9 or higher
+- GCC\* 4.8 or higher to build the Inference Engine
+- GCC\* 5.2 or higher to build the Compute Library for Deep Neural Networks (clDNN library)
+- OpenBLAS\*
+
+### Build Steps
+1. Install OpenBLAS and other dependencies using the `install_dependencies.sh` script in the project root folder.
+2. Create a build folder:
+```sh
+  mkdir build
+```
+3. Inference Engine uses a CMake-based build system. In the created `build` directory, run `cmake` to fetch project dependencies and create Unix makefiles, then run `make` to build the project:
+```sh
+  cmake -DCMAKE_BUILD_TYPE=Release ..
+  make -j16
+```
+You can use the following additional build options:
+- Use `BLAS_INCLUDE_DIRS` and `BLAS_LIBRARIES` cmake options to specify path to OpenBLAS headers and library, for example use the following options on CentOS\*: `-DBLAS_INCLUDE_DIRS=/usr/include/openblas -DBLAS_LIBRARIES=/usr/lib64/libopenblas.so.0`
+- To build clDNN from sources, please specify the `-DENABLE_CLDNN_BUILD=ON` option for `cmake`. By default pre-built version of the clDNN library is used. 
+- To switch on/off the CPU and GPU plugins, use `cmake` options `-DENABLE_MKL_DNN=ON/OFF` and `-DENABLE_CLDNN=ON/OFF`.
+
+## Build on Windows\* Systems:
+
+The software was validated on:
+- Microsoft\* Windows\* 10 with Visual Studio 2017 and Intel® C++ Compiler 2018 Update 3
+- [Intel® Graphics Driver for Windows* [24.20] driver package](https://downloadcenter.intel.com/download/27803/Graphics-Intel-Graphics-Driver-for-Windows-10?v=t).
+
+### Software Requirements
+- [CMake\*](https://cmake.org/download/) 3.9 or higher
+- [OpenBLAS\*](https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download) or 
+- [Intel® C++ Compiler](https://software.intel.com/en-us/intel-parallel-studio-xe) 18.0 to build the Inference Engine on Windows.
+
+### Build Steps
+1. Download and install [Intel® C++ Compiler](https://software.intel.com/en-us/intel-parallel-studio-xe) 18.0
+2. Install OpenBLAS:
+    1. Download [OpenBLAS\*](https://sourceforge.net/projects/openblas/files/v0.2.14/OpenBLAS-v0.2.14-Win64-int64.zip/download)
+    2. Unzip the downloaded package to a directory on your machine. In this document, this directory is referred to as `<OPENBLAS_DIR>`.
+3. Create build directory:
+    ```sh
+    mkdir build
+    ```
+4. In the `build` directory, run `cmake` to fetch project dependencies and generate a Visual Studio solution:
+```sh
+cd build
+cmake -G "Visual Studio 15 2017 Win64" -T "Intel C++ Compiler 18.0" -DOS_FOLDER=ON ^
+    -DBLAS_INCLUDE_DIRS=<OPENBLAS_DIR>\include ^
+    -DBLAS_LIBRARIES=<OPENBLAS_DIR>\lib\libopenblas.dll.a ^
+    -DCMAKE_BUILD_TYPE=Release ^
+    -DICCLIB="C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib" ..
+```
+
+5. Build generated solution in Visual Studio 2017 or run `cmake --build .` to build from the command line.
+
+---
+\* Other names and brands may be claimed as the property of others.

inference-engine/cmake/check_features.cmake

@@ -0,0 +1,134 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+include ("features")
+include("mode")
+include("omp")
+include("itt")
+
+#64 bits platform
+if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
+    message(STATUS "Detected 64 bit architecture")
+    SET(ARCH_64 ON)
+    SET(ARCH_32 OFF)
+else()
+    message(STATUS "Detected 32 bit architecture")
+    SET(ARCH_64 OFF)
+    SET(ARCH_32 ON)
+endif()
+
+if (ARCH_64)
+else()
+    if (UNIX OR APPLE)
+        SET(ENABLE_CLDNN OFF)
+    endif()
+    SET(ENABLE_MKL_DNN OFF)
+endif()
+
+
+#apple specific
+if (APPLE)
+    set(ENABLE_CLDNN OFF)
+endif()
+
+
+#minGW specific - under wine no support for downloading file and applying them using git
+if (WIN32)
+    enable_omp()
+
+    if (MINGW)
+        SET(ENABLE_CLDNN OFF) # dont have mingw dll for linking
+        set(ENABLE_SAMPLES_CORE OFF)
+    endif()
+endif()
+
+# Linux specific - not all OS'es are supported
+if (LINUX)
+    include("linux_name")
+    get_linux_name(LINUX_OS_NAME)
+    if (LINUX_OS_NAME)
+        if (NOT(
+                ${LINUX_OS_NAME} STREQUAL "Ubuntu 14.04" OR
+                ${LINUX_OS_NAME} STREQUAL "Ubuntu 16.04" OR
+                ${LINUX_OS_NAME} STREQUAL "CentOS 7"))
+        endif()
+    else ()
+        message(WARNING "Cannot detect Linux OS via reading /etc/*-release:\n ${release_data}")
+    endif ()
+endif ()
+
+if (NOT ENABLE_MKL_DNN)
+    set(GEMM OPENBLAS)
+endif()
+
+if (NOT ENABLE_VPU)
+    set(ENABLE_MYRIAD OFF)
+endif()
+
+if (NOT ENABLE_MYRIAD)
+    set(ENABLE_VPU OFF)
+endif()
+
+#next section set defines to be accesible in c++/c code for certain feature
+if (ENABLE_PROFILING_RAW)
+    add_definitions(-DENABLE_PROFILING_RAW=1)
+endif()
+
+if (ENABLE_GTEST_PATCHES)
+    add_definitions(-DENABLE_GTEST_PATCHES=1)
+endif()
+
+if (ENABLE_CLDNN)
+    add_definitions(-DENABLE_CLDNN=1)
+endif()
+
+if (ENABLE_MKL_DNN)
+    add_definitions(-DENABLE_MKL_DNN=1)
+endif()
+
+if (ENABLE_STRESS_UNIT_TESTS)
+    add_definitions(-DENABLE_STRESS_UNIT_TESTS=1)
+endif()
+
+if (ENABLE_SEGMENTATION_TESTS)
+    add_definitions(-DENABLE_SEGMENTATION_TESTS=1)
+endif()
+
+if (ENABLE_OBJECT_DETECTION_TESTS)
+    add_definitions(-DENABLE_OBJECT_DETECTION_TESTS=1)
+endif()
+
+#models dependend tests
+
+if (DEVELOPMENT_PLUGIN_MODE)
+    message (STATUS "Enabled development plugin mode")
+
+    set (ENABLE_MKL_DNN OFF)
+    set (ENABLE_TESTS OFF)
+
+    message (STATUS "Initialising submodules")
+    execute_process (COMMAND git submodule update --init ${IE_MAIN_SOURCE_DIR}/thirdparty/pugixml
+                     RESULT_VARIABLE git_res)
+
+    if (NOT ${git_res})
+        message (STATUS "Initialising submodules - done")
+    endif()
+endif()
+
+if (VERBOSE_BUILD)
+    set(CMAKE_VERBOSE_MAKEFILE  ON)
+endif()
+
+if (NOT ENABLE_OMP)
+    set(ENABLE_INTEL_OMP OFF)
+endif()
+
+if (NOT GEMM STREQUAL "MKL" AND NOT GEMM STREQUAL "OPENBLAS")
+    message("FATAL_ERROR" "GEMM should be set to MKL|OPENBLAS")
+endif()
+
+print_enabled_features()
+
+message(STATUS "GEMM = ${GEMM}")

inference-engine/cmake/config.cmake.in

@@ -0,0 +1,11 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+if(DEFINED IE_MAIN_SOURCE_DIR AND TARGET inference_engine)
+    set(InferenceEngine_INCLUDE_DIRS ${IE_MAIN_SOURCE_DIR}/include)
+    set(InferenceEngine_LIBRARIES inference_engine)
+else()
+    include("${CMAKE_CURRENT_LIST_DIR}/targets.cmake")
+    get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
+    set(InferenceEngine_LIBRARIES IE::inference_engine)
+endif()

inference-engine/cmake/debug.cmake

@@ -0,0 +1,69 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+function (debug_message)
+    if (VERBOSE_BUILD)
+        message(${ARGV})
+    endif()
+endfunction()
+
+
+function(clean_message type)
+  string (REPLACE ";" "" output_string "${ARGN}")
+  execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${output_string}")
+  if(${ARGV0} STREQUAL "FATAL_ERROR")
+    message (FATAL_ERROR)
+  endif()  
+endfunction()
+
+file(REMOVE ${CMAKE_BINARY_DIR}/ld_library_rpath_64.txt)
+
+# log relative path to shared library that has to be used in LD_LIBRARY_PATH
+function (log_rpath_remove_top component component_remove_top lib lib_remove_top)
+  
+  set(top_lib_dir ${${component}})
+  set(lib_dir ${lib})
+
+#  debug_message(STATUS "LIB-IN=${lib} ")
+#  debug_message(STATUS "TOPLIB-IN=${top_lib_dir} ")
+  get_filename_component(top_lib_dir ${${component}} DIRECTORY)
+
+  if (${component_remove_top} AND ${component})
+  else()
+    get_filename_component(add_name ${${component}} NAME)
+    set(top_lib_dir "${top_lib_dir}/${add_name}")
+  endif()
+  if (${lib_remove_top} AND lib)
+    get_filename_component(lib_dir ${lib} DIRECTORY)
+  endif()
+
+  string (REPLACE "//" "/" top_lib_dir "${top_lib_dir}")
+  string (REPLACE "//" "/" lib_dir "${lib_dir}")
+
+  string (REPLACE "\\\\" "/" top_lib_dir "${top_lib_dir}")
+  string (REPLACE "\\\\" "/" lib_dir "${lib_dir}")
+
+#  debug_message(STATUS "LIB-OUT=${lib_dir}")
+#  debug_message(STATUS "TOPLIB-OUT=${top_lib_dir}")
+ 
+  string (REPLACE "${top_lib_dir}" "" component_dir "${lib_dir}")
+
+  set(RPATH_INFO "${component}=${component_dir}")
+  debug_message(STATUS "LD_LIBRARY_RPATH: ${RPATH_INFO}")
+  file(APPEND ${CMAKE_BINARY_DIR}/ld_library_rpath_64.txt "${RPATH_INFO}\n")
+endfunction()
+
+function (log_rpath_from_dir component lib_dir)
+  if(NOT APPLE)
+    log_rpath_remove_top("${component}" TRUE "${lib_dir}" FALSE)
+  endif()
+endfunction()
+
+function (log_rpath component lib_path)
+  log_rpath_remove_top(${component} TRUE ${lib_path} TRUE)
+endfunction()
+

inference-engine/cmake/dependencies.cmake

@@ -0,0 +1,117 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required(VERSION 2.8)
+
+#features trigger supported by build system
+include(check_features)
+include(debug)
+
+#we have number of dependencies stored on ftp
+include(dependency_solver)
+
+#prepare temporary folder
+if (DEFINED ENV{${DL_SDK_TEMP}})
+    if (WIN32)
+        string(REPLACE "\\" "\\\\" TEMP $ENV{${DL_SDK_TEMP}})
+    else(WIN32)
+        set(TEMP $ENV{${DL_SDK_TEMP}})
+    endif(WIN32)
+
+    if (ENABLE_ALTERNATIVE_TEMP)
+        set(ALTERNATIVE_PATH ${IE_MAIN_SOURCE_DIR}/temp)
+    endif()
+else ()
+    message(STATUS "DL_SDK_TEMP envionment not set")
+    set(TEMP ${IE_MAIN_SOURCE_DIR}/temp)
+endif ()
+
+
+include(ExternalProject)
+
+if (ENABLE_SAME_BRANCH_FOR_MODELS)
+    branchName(MODELS_BRANCH)
+else()
+    set(MODELS_BRANCH "master")
+endif()
+
+set(MODELS_PATH "${TEMP}/models")
+debug_message(STATUS "MODELS_PATH=" ${MODELS_PATH})
+
+#clDNN
+if (ENABLE_CLDNN AND NOT ENABLE_CLDNN_BUILD)
+if(NOT IE_SUBMODULE_IN_CLDNN)
+    RESOLVE_DEPENDENCY(CLDNN
+            ARCHIVE_UNIFIED "cldnn-main-03988.zip"
+            TARGET_PATH "${TEMP}/clDNN"
+            ENVIRONMENT "CLDNN"
+            VERSION_REGEX ".*_(([a-z]+-)?[a-z]+-[0-9]+)---.*"
+            FOLDER) #new cldnn package dont have toplevel cldnn folder
+    debug_message(STATUS "clDNN=" ${CLDNN})
+endif ()
+endif ()
+
+## enable cblas_gemm from OpenBLAS package
+if (GEMM STREQUAL "OPENBLAS")
+if(NOT BLAS_LIBRARIES OR NOT BLAS_INCLUDE_DIRS)
+    find_package(BLAS REQUIRED)
+    if(BLAS_FOUND)
+        find_path(BLAS_INCLUDE_DIRS cblas.h)
+    else()
+        message(ERROR "OpenBLAS not found: install OpenBLAS or set -DBLAS_INCLUDE_DIRS=<path to dir with cblas.h> and -DBLAS_LIBRARIES=<path to libopenblas.so or openblas.lib>")
+    endif()
+endif()
+debug_message(STATUS "openblas=" ${BLAS_LIBRARIES})
+endif ()
+
+#MKL-ml package
+if (GEMM STREQUAL "MKL" OR ENABLE_INTEL_OMP)
+if (WIN32)
+    RESOLVE_DEPENDENCY(MKL
+            ARCHIVE_WIN "mkltiny_win_20180512.zip"
+            TARGET_PATH "${TEMP}/mkltiny_win_20180512"
+            ENVIRONMENT "MKLROOT"
+            VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+elseif(LINUX)
+    RESOLVE_DEPENDENCY(MKL
+            ARCHIVE_LIN "mkltiny_lnx_20180511.tgz"
+            TARGET_PATH "${TEMP}/mkltiny_lnx_20180511"
+            ENVIRONMENT "MKLROOT"
+            VERSION_REGEX ".*_([a-z]*_([a-z0-9]+\\.)*[0-9]+).*")
+endif()
+debug_message(STATUS "mkl_ml=" ${MKL})
+endif ()
+
+if (ENABLE_OPENCV)
+if (WIN32)
+    RESOLVE_DEPENDENCY(OPENCV
+            ARCHIVE_WIN "opencv_3.4.3.zip"
+            TARGET_PATH "${TEMP}/opencv"
+            ENVIRONMENT "OpenCV_DIR"
+            VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
+    log_rpath_from_dir(OPENCV "\\opencv\\x64\\vc14\\bin")
+    set( ENV{OpenCV_DIR} ${OPENCV} )
+elseif(LINUX)
+if (${LINUX_OS_NAME} STREQUAL "Ubuntu 16.04")
+    RESOLVE_DEPENDENCY(OPENCV
+            ARCHIVE_LIN "opencv_3.4.3_ubuntu16.tar.bz2"
+            TARGET_PATH "${TEMP}/opencv_ubuntu16"
+            ENVIRONMENT "OpenCV_DIR"
+            VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
+    log_rpath_from_dir(OPENCV "opencv_ubuntu16/lib")
+elseif (${LINUX_OS_NAME} STREQUAL "CentOS 7")
+    RESOLVE_DEPENDENCY(OPENCV
+            ARCHIVE_LIN "opencv_3.4.3_centos7.tar.bz2"
+            TARGET_PATH "${TEMP}/opencv_centos7"
+            ENVIRONMENT "OpenCV_DIR"
+            VERSION_REGEX ".*_([0-9]+.[0-9]+.[0-9]+).*")
+    log_rpath_from_dir(OPENCV "opencv_centos7/lib")
+endif()
+    set( ENV{OpenCV_DIR} ${OPENCV}/share )
+endif()
+debug_message(STATUS "opencv=" ${OPENCV})
+endif()
+
+include(omp)

inference-engine/cmake/dependency_solver.cmake

@@ -0,0 +1,140 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+include ("download")
+
+function (resolve_archive_dependency VAR COMPONENT ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC TARGET_PATH FOLDER ENVIRONMENT)
+
+  if (ENVIRONMENT AND (DEFINED ENV{${ENVIRONMENT}}))
+    set(HAS_ENV "TRUE")
+  endif()
+
+  if (NOT DEFINED HAS_ENV)
+    if (ARCHIVE)
+      #TODO: check wether this is platform specific binary with same name per or it is in common folder
+      DownloadAndExtract(${COMPONENT} ${ARCHIVE} ${TARGET_PATH} result_path ${FOLDER})
+    else()
+      DownloadAndExtractPlatformSpecific(${COMPONENT} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${TARGET_PATH} result_path  ${FOLDER})
+    endif()
+
+    set (${VAR} ${result_path} PARENT_SCOPE)
+  else()
+    set (${VAR} $ENV{${ENVIRONMENT}} PARENT_SCOPE)
+  endif()
+
+endfunction(resolve_archive_dependency)
+
+function(resolve_pull_request GITHUB_PULL_REQUEST TARGET_PATH)
+    get_filename_component(FILE_NAME ${GITHUB_PULL_REQUEST} NAME)
+    set (PATCH_URL "")
+    DownloadAndApply("${PATCH_URL}/${GITHUB_PULL_REQUEST}" "${IE_MAIN_SOURCE_DIR}/${TARGET_PATH}/${FILE_NAME}")
+endfunction(resolve_pull_request)
+
+function(extract_version_from_filename filename regex version)
+    string(REGEX MATCH ${regex} match ${filename})
+
+    if (CMAKE_MATCH_1)
+        set(${version} ${CMAKE_MATCH_1} PARENT_SCOPE)
+    else()
+        set(${version} ${filename} PARENT_SCOPE)
+    endif()
+endfunction(extract_version_from_filename)
+
+function(read_version archive regex version_var)
+    extract_version_from_filename(${archive} ${regex} version)
+    set(${version_var} "${version}" CACHE INTERNAL "" FORCE)
+    debug_message(STATUS "${version_var} = " ${version})
+endfunction(read_version)
+
+function (RESOLVE_DEPENDENCY NAME_OF_CMAKE_VAR)
+
+  list(REMOVE_AT ARGV 0)
+  set(SUPPORTED_ARGS FOLDER ARCHIVE ARCHIVE_UNIFIED ARCHIVE_WIN ARCHIVE_LIN ARCHIVE_MAC TARGET_PATH ENVIRONMENT GITHUB_PULL_REQUEST VERSION_REGEX)
+
+
+  #unnecessary vars
+  foreach(arg ${ARGV})
+    #message("one_arg=" ${one_arg})
+    #message("arg=" ${arg})
+    #parse no arg vars
+    if (";${SUPPORTED_ARGS};" MATCHES ";${arg};")
+      if(DEFINED one_arg)
+        set(${one_arg} TRUE)
+      endif()
+      set (one_arg ${arg})
+    elseif(DEFINED one_arg)
+      set(${one_arg} ${arg})
+      unset(one_arg)
+    else()
+      message(FATAL_ERROR "invalid argument passed to resolve dependency: " ${arg})
+    endif()
+  endforeach(arg)
+
+  #if last token was bool
+  if(DEFINED one_arg)
+    set(${one_arg} TRUE)
+  endif()
+
+
+  if (NOT DEFINED ARCHIVE)
+    SET(ARCHIVE "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_UNIFIED)
+    SET(ARCHIVE_UNIFIED "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_WIN)
+    SET(ARCHIVE_WIN "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_LIN)
+    SET(ARCHIVE_LIN "OFF")
+  endif()
+
+  if (NOT DEFINED ARCHIVE_MAC)
+    SET(ARCHIVE_MAC "OFF")
+  endif()
+
+  if (NOT DEFINED ENVIRONMENT)
+    set (ENVIRONMENT "OFF")
+  endif()
+
+  if (NOT DEFINED FOLDER)
+    set (FOLDER FALSE)
+  endif()
+
+  #for each dependency type have to do separate things
+  if (ARCHIVE_WIN OR ARCHIVE_LIN OR ARCHIVE_MAC OR ARCHIVE OR ARCHIVE_UNIFIED)
+    if (NOT DEFINED TARGET_PATH)
+      message(FATAL_ERROR "TARGET_PATH should be defined for every dependency")
+    endif()
+
+    resolve_archive_dependency(RESULT ${NAME_OF_CMAKE_VAR} ${ARCHIVE} ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC} ${TARGET_PATH} ${FOLDER} ${ENVIRONMENT})
+    set(${NAME_OF_CMAKE_VAR} ${RESULT} PARENT_SCOPE)
+    if (VERSION_REGEX)
+        GetNameAndUrlToDownload(archive RELATIVE_URL ${ARCHIVE_UNIFIED} ${ARCHIVE_WIN} ${ARCHIVE_LIN} ${ARCHIVE_MAC})
+        if (archive)
+            read_version(${archive} ${VERSION_REGEX} "${NAME_OF_CMAKE_VAR}_VERSION")
+        endif()
+    endif()
+
+  elseif (DEFINED GITHUB_PULL_REQUEST)
+    resolve_pull_request(${GITHUB_PULL_REQUEST} ${TARGET_PATH})
+  else()
+    message(FATAL_ERROR "Dependency of unknowntype, SHOULD set one of ARCHIVE_WIN, ARCHIVE, ARCHIVE_LIN, ARCHIVE_MAC, GITHUB_PULL_REQUEST")
+  endif()
+
+endfunction(RESOLVE_DEPENDENCY)
+
+function (resolve_model_dependency network archive network_model_path)
+  RESOLVE_DEPENDENCY(${network_model_path}
+        ARCHIVE "models_archives/${archive}"
+        TARGET_PATH "${MODELS_PATH}/${network}")
+  string (REPLACE ${MODELS_PATH} "" relative_path ${${network_model_path}})
+  set(${network_model_path} ".${relative_path}" PARENT_SCOPE)
+endfunction()

inference-engine/cmake/download.cmake

@@ -0,0 +1,27 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+function (Download from to fatal result output)
+
+  if((NOT EXISTS "${to}"))
+    message(STATUS "Downloading from ${from} to ${to} ...")
+    file(DOWNLOAD ${from} ${to}
+      TIMEOUT 3600
+      LOG log
+      STATUS status
+      SHOW_PROGRESS)
+
+    set (${output} ${status} PARENT_SCOPE)
+  else()
+    set (${output} 0 PARENT_SCOPE)
+  endif()
+  set(${result} "ON" PARENT_SCOPE)
+
+endfunction(Download)
+
+include ("download_and_apply")
+include ("download_and_extract")

inference-engine/cmake/download_and_apply.cmake

@@ -0,0 +1,52 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+function (DownloadAndApply URL apply_to)
+
+  if (EXISTS ${apply_to})
+    file(READ ${apply_to} patchFile4Bytes LIMIT 4)
+  endif()
+  debug_message(STATUS "patchFile=" ${apply_to})
+  debug_message(STATUS "patchFile4Bytes=" ${patchFileSize} "\"")
+
+  if (NOT EXISTS ${apply_to} OR NOT patchFile4Bytes)
+    #remove empty file
+    if (EXISTS ${apply_to})
+      file(REMOVE ${apply_to})
+    endif()
+    
+    DownloadAndCheck(${URL} ${apply_to} TRUE result)
+  else ()
+    set (MIGHT_BE_APPLIED 1)
+  endif()
+
+    get_filename_component(apply_dir ${apply_to} DIRECTORY)
+    get_filename_component(patch_name ${apply_to} NAME)
+
+    # git apply silently if file wasnot downloaded :
+    #
+    if (NOT DEFINED MIGHT_BE_APPLIED)
+        debug_message(STATUS "applying patch ... ")
+    endif()
+
+if (NOT MINGW)
+    execute_process(COMMAND git apply --verbose  ${patch_name}
+      WORKING_DIRECTORY ${apply_dir}
+      RESULT_VARIABLE rv
+      ERROR_VARIABLE err)
+else()
+    debug_message("git patch: " ${patch_name} " not applied under MINGW, however it downloaded")
+endif()
+
+    #TODO:bad patch indicator either it is bad by itself of failed to apply
+    #currently cannot detect what happened 
+    if (NOT DEFINED MIGHT_BE_APPLIED AND NOT (rv EQUAL 0))
+      file(REMOVE_RECURSE "${apply_to}")
+      debug_message(FATAL_ERROR "cannot apply patch ${patch_name} " ${err})
+    endif()
+  
+endfunction(DownloadAndApply)

inference-engine/cmake/download_and_check.cmake

@@ -0,0 +1,56 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+include (FindWget)
+
+function (DownloadAndCheck from to fatal result)
+    set(status_res "ON")
+    set(output 1)
+
+    get_filename_component(download_dir ${to} DIRECTORY)
+    if (NOT EXISTS ${download_dir})
+      file(MAKE_DIRECTORY ${download_dir})
+    endif()
+
+    if(NOT EXISTS "${to}")
+      message(STATUS "Downloading from ${from} to ${to} ...")
+
+      find_program(aria2c "aria2c")
+      if (${aria2c} STREQUAL "aria2c-NOTFOUND")
+        if (NOT ${WGET_FOUND})
+          Download(${from} ${to} ${fatal} ${result} output)
+          list(GET output 0 status_code)
+        else()
+          message(STATUS "${WGET_EXECUTABLE} --no-cache ${from}")
+          execute_process(COMMAND ${WGET_EXECUTABLE} "--no-cache" "${from}" "-O" "${to}"
+            TIMEOUT 2000
+            RESULT_VARIABLE status_code)
+        endif()
+      else()
+        message(STATUS "${aria2c} ,*.*.*.* -d ${download_dir} ${from}")
+        execute_process(COMMAND "${aria2c}" "-s10" "-x10" "--dir=${download_dir}" "${from}"
+            TIMEOUT 2000
+            RESULT_VARIABLE status_code)
+      endif()
+
+      if(NOT status_code EQUAL 0)
+        if (fatal)
+          message(FATAL_ERROR "fatal error: downloading '${from}' failed
+            status_code: ${status_code}
+            status_string: ${status_string}
+            log: ${log}")
+        else()
+          set(status_res "ARCHIVE_DOWNLOAD_FAIL")
+          message("error: downloading '${from}' failed
+            status_code: ${status_code}")
+        endif()
+      endif()
+    endif()
+
+  file(REMOVE ${to}.md5)
+  set(${result} "${status_res}" PARENT_SCOPE)
+
+endfunction(DownloadAndCheck)

inference-engine/cmake/download_and_extract.cmake

@@ -0,0 +1,216 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+include ("extract")
+include ("download_and_check")
+
+function (GetNameAndUrlToDownload name url archive_name_unified archive_name_win archive_name_lin archive_name_mac)
+  if (archive_name_unified)
+    set (${url} "${archive_name_unified}" PARENT_SCOPE)
+    set (${name} ${archive_name_unified} PARENT_SCOPE)
+  else()
+    if (LINUX OR (APPLE AND NOT archive_name_mac))
+      if (NOT archive_name_lin)
+        return()
+      endif()  
+      set (PLATFORM_FOLDER linux)
+      set (archive_name ${archive_name_lin})
+    elseif(APPLE)
+      if (NOT archive_name_mac)
+        return()
+      endif()  
+      set (PLATFORM_FOLDER mac)
+      set (archive_name ${archive_name_mac})
+    else()
+      #if no dependency for target platfrom skip it
+      if (NOT archive_name_win)
+        return()
+      endif()
+      set (PLATFORM_FOLDER windows)
+      set (archive_name ${archive_name_win})
+    endif()
+
+    set (${name} ${archive_name} PARENT_SCOPE)
+    set (${url}  "${archive_name}" PARENT_SCOPE)
+  endif()
+endfunction(GetNameAndUrlToDownload)
+
+#download from paltform specific folder from share server
+function (DownloadAndExtractPlatformSpecific 
+  component 
+  archive_name_unified 
+  archive_name_win 
+  archive_name_lin 
+  archive_name_mac 
+  unpacked_path 
+  result_path
+  folder)
+
+  GetNameAndUrlToDownload(archive_name RELATIVE_URL ${archive_name_unified} ${archive_name_win} ${archive_name_lin} ${archive_name_mac} )
+  if (NOT archive_name OR NOT RELATIVE_URL)
+    return()
+  endif()
+  CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} result_path2 ${folder} TRUE FALSE TRUE)
+  set (${result_path} ${result_path2} PARENT_SCOPE)
+
+endfunction(DownloadAndExtractPlatformSpecific)
+
+#download from common folder
+function (DownloadAndExtract component archive_name unpacked_path result_path folder)
+  set (RELATIVE_URL  "${archive_name}")
+  set(fattal TRUE)
+  CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} result_path2 ${folder} ${fattal} result TRUE)
+  
+  if (NOT ${result})
+    DownloadAndExtractPlatformSpecific(${component} ${archive_name} ${archive_name} ${archive_name} ${unpacked_path} ${result_path2} ${folder})
+  endif()  
+
+  set (${result_path} ${result_path2} PARENT_SCOPE)
+
+endfunction(DownloadAndExtract)
+
+
+function (DownloadAndExtractInternal URL archive_path  unpacked_path folder fattal result123)
+  set (status "ON")
+  DownloadAndCheck(${URL} ${archive_path} ${fattal} result1)
+  if ("${result1}" STREQUAL "ARCHIVE_DOWNLOAD_FAIL")
+    #check alternative url as well
+    set (status "OFF")
+    file(REMOVE_RECURSE "${archive_path}")    
+  endif()
+
+  if ("${result1}" STREQUAL "CHECKSUM_DOWNLOAD_FAIL" OR "${result1}" STREQUAL "HASH_MISMATCH")
+    set(status FALSE)
+    file(REMOVE_RECURSE "${archive_path}")    
+  endif()
+
+  if("${status}" STREQUAL "ON")
+    ExtractWithVersion(${URL} ${archive_path} ${unpacked_path} ${folder} result)
+  endif()
+  
+  set (result123 ${status} PARENT_SCOPE)
+
+endfunction(DownloadAndExtractInternal)
+
+function (ExtractWithVersion URL archive_path unpacked_path folder result)
+
+  debug_message("ExtractWithVersion : ${archive_path} : ${unpacked_path}")
+  extract(${archive_path} ${unpacked_path} ${folder} status)
+  #dont need archive actually after unpacking
+  file(REMOVE_RECURSE "${archive_path}")  
+  if (${status})
+    set (version_file ${unpacked_path}/ie_dependency.info)
+    file(WRITE ${version_file} ${URL})
+  else()
+    file(REMOVE_RECURSE "${unpacked_path}")
+  endif()
+  set (${result} ${status} PARENT_SCOPE)  
+endfunction (ExtractWithVersion)
+
+function (DownloadOrExtractInternal URL archive_path unpacked_path folder fattal result123)
+  debug_message("checking wether archive downloaded : ${archive_path}")
+
+  if (NOT EXISTS ${archive_path})
+    DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)
+  else()
+
+    if (ENABLE_UNSAFE_LOCATIONS)
+      ExtractWithVersion(${URL} ${archive_path} ${unpacked_path} ${folder} result)
+      if(NOT ${result})
+        DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)      
+      endif()
+    else()
+      debug_message("archive found on FS : ${archive_path}, however we cannot check it's checksum and think that it is invalid")
+      file(REMOVE_RECURSE "${archive_path}")
+      DownloadAndExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} result)      
+    endif()  
+
+  
+  endif()  
+
+  if (NOT ${result})
+    message(FATAL_ERROR "error: extract of '${archive_path}' failed")
+  endif()
+
+endfunction(DownloadOrExtractInternal)
+
+file(REMOVE ${CMAKE_BINARY_DIR}/dependencies_64.txt)
+
+function (CheckOrDownloadAndExtract component RELATIVE_URL archive_name unpacked_path result_path folder fattal result123 use_alternatives)
+  set (archive_path ${TEMP}/download/${archive_name})
+  set (status "ON")
+  set (on_master FALSE)
+
+  set (URL  "https://download.01.org/openvinotoolkit/2018_R3/dldt/inference_engine/${RELATIVE_URL}")
+
+  #no message on recursive calls
+  if (${use_alternatives})
+    set(DEP_INFO "${component}=${URL}")
+    debug_message (STATUS "DEPENDENCY_URL: ${DEP_INFO}")
+    file(APPEND ${CMAKE_BINARY_DIR}/dependencies_64.txt "${DEP_INFO}\n")
+  endif()
+
+  debug_message ("checking that unpacked directory exist: ${unpacked_path}")
+
+  if (NOT EXISTS ${unpacked_path})
+    DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} status)
+  else(NOT EXISTS ${unpacked_path})  
+    #path exists, so we would like to check what was unpacked version
+    set (version_file ${unpacked_path}/ie_dependency.info)
+
+    if (DEFINED TEAMCITY_GIT_BRANCH)
+      if(${TEAMCITY_GIT_BRANCH} STREQUAL "master")
+        set(on_master TRUE)
+        debug_message ("On master branch, update data in DL_SDK_TEMP if necessary")
+      endif()
+    endif()
+
+    if (NOT EXISTS ${version_file} AND NOT ${ENABLE_ALTERNATIVE_TEMP})
+      clean_message(FATAL_ERROR "error: Dependency doesn't contain version file. Please select actions: \n"
+        "if you are not sure about your FS dependency - remove it : \n"
+        "\trm -rf ${unpacked_path}\n"
+        "and rerun cmake.\n"
+        "If your dependency is fine, then execute:\n\techo ${URL} > ${unpacked_path}/ie_dependency.info\n")
+#     file(REMOVE_RECURSE "${unpacked_path}") 
+#     DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${fattal} status)
+    else()
+      if (EXISTS ${version_file})
+        file(READ "${version_file}" dependency_url)
+        string(REGEX REPLACE "\n" ";" dependency_url "${dependency_url}")
+        #we have decided to stick each dependency to unique url that will be that record in version file
+        debug_message("dependency_info on FS : \"${dependency_url}\"\n"
+                      "compare to            : \"${URL}\"" )
+      else ()
+        debug_message("no version file available at ${version_file}")
+      endif()
+
+    if (NOT EXISTS ${version_file} OR NOT ${dependency_url} STREQUAL ${URL})
+      if (${use_alternatives} AND ALTERNATIVE_PATH AND NOT ${on_master})
+        #creating alternative_path
+        string(REPLACE ${TEMP} ${ALTERNATIVE_PATH} unpacked_path ${unpacked_path})
+        string(REPLACE ${TEMP} ${ALTERNATIVE_PATH} archive_path ${archive_path})
+
+        debug_message("dependency different: use local path for fetching updated version: ${alternative_path}")
+        CheckOrDownloadAndExtract(${component} ${RELATIVE_URL} ${archive_name} ${unpacked_path} ${result_path} ${folder} ${fattal} ${result123} FALSE)
+
+      else()
+        debug_message("dependency updated: download it again")
+        file(REMOVE_RECURSE "${unpacked_path}") 
+        DownloadOrExtractInternal(${URL} ${archive_path} ${unpacked_path} ${folder} ${fattal} status)
+      endif()
+    endif ()
+   endif()
+  endif()
+
+  if (${use_alternatives} OR ${on_master})
+    set (${result123} "${status}" PARENT_SCOPE)
+    set (${result_path} ${unpacked_path} PARENT_SCOPE)
+  endif()
+
+  
+  
+endfunction(CheckOrDownloadAndExtract)
+

inference-engine/cmake/extract.cmake

@@ -0,0 +1,48 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+function (extract archive_path unpacked_path folder result)
+  # Slurped from a generated extract-TARGET.cmake file.
+  if (NOT EXISTS ${unpacked_path})
+    get_filename_component(unpacked_dir ${unpacked_path} DIRECTORY)
+    
+    file(MAKE_DIRECTORY ${unpacked_path})
+    
+    message(STATUS "extracting...
+         src='${archive_path}'
+         dst='${unpacked_path}'")
+
+    if(NOT EXISTS "${archive_path}")
+      message(FATAL_ERROR "error: file to extract does not exist: '${archive_path}'")
+    endif()
+
+    # Extract it:
+    #
+    # in case of archive dont have top level folder lets create it
+    if (${folder})
+      set (unpacked_dir ${unpacked_path})
+      message("unpacked_dir= ${unpacked_dir}")      
+    endif()
+
+    message(STATUS "extracting... [tar xfz]")
+    execute_process(COMMAND ${CMAKE_COMMAND} -E tar xfz ${archive_path} 
+      WORKING_DIRECTORY ${unpacked_dir}
+      RESULT_VARIABLE rv
+      ERROR_VARIABLE err)
+
+    if (NOT (err STREQUAL ""))
+      message(STATUS "error: extract of '${archive_path}' failed: ${err}")
+      #invalid archive
+      file(REMOVE_RECURSE "${unpacked_path}")
+      file(REMOVE_RECURSE "${archive_path}")
+      set(${result} 0 PARENT_SCOPE)
+    else()
+      set(${result} 1 PARENT_SCOPE)
+    endif()
+    
+  endif()
+endfunction (extract)

inference-engine/cmake/features.cmake

@@ -0,0 +1,63 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required (VERSION 2.8)
+
+include ("options")
+
+#this options are aimed to optimize build time on development system
+
+#backed targets
+
+ie_option (ENABLE_MKL_DNN "MKL-DNN plugin for inference engine" ON)
+
+ie_option (ENABLE_CLDNN "clDnn based plugin for inference engine" ON)
+
+ie_option (ENABLE_CLDNN_BUILD "build clDnn from sources" OFF)
+
+ie_option (ENABLE_PROFILING_ITT "ITT tracing of IE and plugins internals" ON)
+
+ie_option (ENABLE_PROFILING_RAW "Raw counters profiling (just values, no start/stop time or timeline)" OFF)
+
+# "MKL-DNN library might use MKL-ML or OpenBLAS for gemm tasks: OPENBLAS|MKL"
+if (NOT GEMM)
+    set (GEMM "OPENBLAS")
+endif()
+
+ie_option (ENABLE_OMP "MKL-DNN library based on OMP implementation" ON)
+
+ie_option (ENABLE_INTEL_OMP "MKL-DNN library based on Intel OMP implementation" ON)
+
+ie_option (ENABLE_TESTS "unit and functional tests" OFF)
+
+ie_option (ENABLE_SAMPLES_CORE "console samples core library" ON)
+
+ie_option (ENABLE_SANITIZER "enable checking memory errors via AddressSanitizer" OFF)
+
+ie_option (COVERAGE "enable code coverage" OFF)
+
+ie_option (ENABLE_STRESS_UNIT_TESTS "stress unit tests" OFF)
+
+ie_option (VERBOSE_BUILD "shows extra information about build" OFF)
+
+ie_option (ENABLE_UNSAFE_LOCATIONS "skip check for MD5 for dependency" OFF)
+
+ie_option (ENABLE_ALTERNATIVE_TEMP "in case of dependency conflict, to avoid modification in master, use local copy of dependency" ON)
+
+ie_option (ENABLE_SEGMENTATION_TESTS "segmentation tests" ON)
+
+ie_option (ENABLE_OBJECT_DETECTION_TESTS "object detection tests" ON)
+
+ie_option (ENABLE_OPENCV "enables OpenCV" ON)
+
+ie_option (OS_FOLDER "create OS dedicated folder in output" OFF)
+
+ie_option (ENABLE_PLUGIN_RPATH "enables rpath information to be present in plugins binary, and in corresponding test_applications" ON)
+
+#environment variables used
+
+#name of environment variable stored path to temp directory"
+set (DL_SDK_TEMP  "DL_SDK_TEMP")
+

inference-engine/cmake/itt.cmake

@@ -0,0 +1,62 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+unset(ITT_INCLUDE_DIR CACHE)
+unset(ITT_LIB CACHE)
+
+if(NOT DEFINED INTEL_VTUNE_DIR AND DEFINED ENV{INTEL_VTUNE_DIR})
+    set(INTEL_VTUNE_DIR "$ENV{INTEL_VTUNE_DIR}")
+endif()
+if(NOT DEFINED INTEL_VTUNE_DIR)
+    if(EXISTS "/opt/intel/vtune_amplifier_xe/include")
+    	set(INTEL_VTUNE_DIR "/opt/intel/vtune_amplifier_xe")
+    elseif(EXISTS "/opt/intel/vtune_amplifier/include")
+        set(INTEL_VTUNE_DIR "/opt/intel/vtune_amplifier")
+    elseif (EXISTS "C:/Program Files (x86)/IntelSWTools/VTune Amplifier XE")
+        set(INTEL_VTUNE_DIR "C:/Program Files (x86)/IntelSWTools/VTune Amplifier XE")
+    elseif (EXISTS "C:/Program Files (x86)/IntelSWTools/VTune Amplifier")
+        set(INTEL_VTUNE_DIR "C:/Program Files (x86)/IntelSWTools/VTune Amplifier")
+    endif()
+endif()
+
+if(DEFINED INTEL_VTUNE_DIR)
+    message(STATUS "INTEL_VTUNE_DIR = ${INTEL_VTUNE_DIR}")
+
+    find_path(ITT_INCLUDE_DIR
+    FILES
+        ittnotify.h
+    PATHS "${INTEL_VTUNE_DIR}/include/")
+
+    find_library(ITT_LIB
+    "libittnotify${CMAKE_STATIC_LIBRARY_SUFFIX}"
+    PATHS ${INTEL_VTUNE_DIR}/lib64)
+
+    set(Located_ITT_LIBS ${ITT_LIB} ${CMAKE_DL_LIBS})
+    set(Located_ITT_INCLUDE_DIRS ${ITT_INCLUDE_DIR})
+else()
+    message(STATUS "INTEL_VTUNE_DIR is not defined")
+endif()
+
+# Handle find_package() arguments, and set INTEL_ITT_FOUND
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(INTEL_ITT
+    REQUIRED_VARS
+        Located_ITT_INCLUDE_DIRS
+        Located_ITT_LIBS)
+
+if(ENABLE_PROFILING_ITT AND INTEL_ITT_FOUND)
+    add_definitions(-DENABLE_PROFILING_ITT=1)
+
+    set(INTEL_ITT_LIBS ${Located_ITT_LIBS})
+    set(INTEL_ITT_INCLUDE_DIRS ${Located_ITT_INCLUDE_DIRS})
+
+    message(STATUS "INTEL_ITT_INCLUDE_DIRS: ${INTEL_ITT_INCLUDE_DIRS}")
+    include_directories(${INTEL_ITT_INCLUDE_DIRS})
+    message(STATUS "INTEL_ITT_LIBS: ${INTEL_ITT_LIBS}")
+else()
+    add_definitions(-DENABLE_PROFILING_ITT=0)
+    message(STATUS "INTEL_ITT is disabled")
+endif()
+

inference-engine/cmake/linux_name.cmake

@@ -0,0 +1,35 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required(VERSION 2.8)
+
+if (UNIX)
+    function(get_linux_name res_var)
+        if (NOT EXISTS "/etc/lsb-release")
+            execute_process(COMMAND find /etc/ -maxdepth 1 -type f -name *-release -exec cat {} \;
+                    OUTPUT_VARIABLE release_data RESULT_VARIABLE result)
+            set(name_regex "NAME=\"([^ \"\n]*).*\"\n")
+            set(version_regex "VERSION=\"([0-9]+(\\.[0-9]+)?)[^\n]*\"")
+        else ()
+            #linux version detection using cat /etc/lsb-release
+            file(READ "/etc/lsb-release" release_data)
+            set(name_regex "DISTRIB_ID=([^ \n]*)\n")
+            set(version_regex "DISTRIB_RELEASE=([0-9]+(\\.[0-9]+)?)")
+        endif ()
+
+        string(REGEX MATCH ${name_regex} name ${release_data})
+        set(os_name ${CMAKE_MATCH_1})
+
+        string(REGEX MATCH ${version_regex} version ${release_data})
+        set(os_name "${os_name} ${CMAKE_MATCH_1}")
+
+        if (os_name)
+            set(${res_var} ${os_name} PARENT_SCOPE)
+        else ()
+            set(${res_var} NOTFOUND PARENT_SCOPE)
+        endif ()
+
+    endfunction()
+endif ()

inference-engine/cmake/mode.cmake

@@ -0,0 +1,6 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+option(DEVELOPMENT_PLUGIN_MODE "Disabled build of all plugins" OFF)

inference-engine/cmake/omp.cmake

@@ -0,0 +1,57 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (APPLE OR WIN32)
+
+    find_path(OMP_INC omp.h)
+    find_library(OMP_LIB iomp5
+        PATHS   ${MKL}/lib)
+
+    if (OMP_INC AND OMP_LIB)
+        set(HAVE_OMP TRUE)
+        get_filename_component(OMP_LIB_DIR "${OMP_LIB}" PATH)
+    else()
+        if (ENABLE_OMP)
+            find_package(OpenMP)
+            if (NOT OPENMP_FOUND)    
+                message(WARNING "OpenMP not found. OpenMP support will be disabled.")
+            endif()
+        endif()
+    endif()
+endif()
+
+
+macro(enable_omp)
+    if (APPLE) ## MacOS
+        if (HAVE_OMP)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp=libiomp5")
+            set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -L${OMP_LIB_DIR}")
+        else()
+            message(WARNING "Was trying to enable OMP for some target. However OpenMP was not detected on system.")
+        endif()
+    elseif(UNIX) # Linux
+        add_definitions(-fopenmp)
+    elseif(WIN32) # Windows
+        if (ENABLE_OMP)
+            set(OPENMP_FLAGS "/Qopenmp /openmp")
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CCXX_FLAGS} ${OPENMP_FLAGS}")
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CCXX_FLAGS} ${OPENMP_FLAGS}")
+        endif()
+    endif()
+
+    if (ENABLE_INTEL_OMP)
+        if (WIN32)
+            find_library(intel_omp_lib
+                libiomp5md
+                PATHS ${MKL}/lib ${ICCLIB})
+            set (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /nodefaultlib:vcomp")
+            set (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /nodefaultlib:vcomp")
+        else()
+            find_library(intel_omp_lib
+                    iomp5
+                    PATHS ${MKL}/lib)
+        endif()
+    endif()
+endmacro(enable_omp)

inference-engine/cmake/options.cmake

@@ -0,0 +1,20 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+function (ie_option variable description value)
+    option(${variable} "${description}" ${value})
+    list (APPEND IE_OPTIONS "${variable}")
+
+    set (IE_OPTIONS "${IE_OPTIONS}" PARENT_SCOPE)
+endfunction()
+
+include(version)
+
+function (print_enabled_features)
+    message(STATUS "CI_BUILD_NUMBER: ${CI_BUILD_NUMBER}")
+    foreach(_var ${IE_OPTIONS})
+        message(STATUS "${_var} = ${${_var}}")
+    endforeach()
+endfunction()

inference-engine/cmake/os_flags.cmake

@@ -0,0 +1,18 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (WIN32)
+    set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS _CRT_SECURE_NO_WARNINGS)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SCL_SECURE_NO_WARNINGS")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") #no asynchronous structured exception handling
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /LARGEADDRESSAWARE")
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Werror=return-type ")
+    if (APPLE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-error=unused-command-line-argument")
+    elseif(UNIX)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wuninitialized -Winit-self -Wmaybe-uninitialized")
+    endif()
+endif()

inference-engine/cmake/sanitizer.cmake

@@ -0,0 +1,11 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (ENABLE_SANITIZER)
+    set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fsanitize=address -fuse-ld=gold")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fuse-ld=gold")
+    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
+endif()

inference-engine/cmake/sdl.cmake

@@ -0,0 +1,36 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+if (UNIX OR APPLE)
+    set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fPIE -fPIC -Wformat -Wformat-security")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
+    set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -D_FORTIFY_SOURCE=2")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pie")
+    if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -z noexecstack -z relro -z now")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -z noexecstack -z relro -z now")
+        if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.9)
+            set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-all")
+        else()
+            set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-strong")
+        endif()
+    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+        set(CMAKE_CCXX_FLAGS "${CMAKE_CCXX_FLAGS} -fstack-protector-all")
+    elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -z noexecstack -z relro -z now")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -z noexecstack -z relro -z now")
+    endif()
+
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_CCXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CCXX_FLAGS}")
+
+
+elseif (WIN32)
+    elseif (${CMAKE_CXX_COMPILER_ID} STREQUAL MSVC)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP /sdl")
+
+endif()
+

inference-engine/cmake/share/InferenceEngineConfig-version.cmake

@@ -0,0 +1,17 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+set(InferenceEngine_VERSION 1.2.0)
+set(PACKAGE_VERSION ${InferenceEngine_VERSION})
+
+set(PACKAGE_VERSION_EXACT False)
+set(PACKAGE_VERSION_COMPATIBLE False)
+
+if(PACKAGE_FIND_VERSION VERSION_EQUAL PACKAGE_VERSION)
+  set(PACKAGE_VERSION_EXACT True)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()
+
+if(PACKAGE_FIND_VERSION VERSION_LESS PACKAGE_VERSION)
+  set(PACKAGE_VERSION_COMPATIBLE True)
+endif()

inference-engine/cmake/share/InferenceEngineConfig.cmake

@@ -0,0 +1,151 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+# FindIE
+# ------
+#
+#   You can specify the path to Inference Engine files in IE_ROOT_DIR
+#
+# This will define the following variables:
+#
+#   InferenceEngine_FOUND        - True if the system has the Inference Engine library
+#   InferenceEngine_INCLUDE_DIRS - Inference Engine include directories
+#   InferenceEngine_LIBRARIES    - Inference Engine libraries
+#
+# and the following imported targets:
+#
+#   IE::inference_engine    - The Inference Engine library
+#
+
+
+set(InferenceEngine_FOUND FALSE)
+
+if(TARGET IE::inference_engine)
+    set(InferenceEngine_FOUND TRUE)
+    get_target_property(InferenceEngine_INCLUDE_DIRS IE::inference_engine INTERFACE_INCLUDE_DIRECTORIES)
+    set(InferenceEngine_LIBRARIES IE::inference_engine)
+else()
+    if (WIN32)
+        set(_ARCH intel64)
+    else()
+        if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "x86_64")
+            set(_ARCH intel64)
+        elseif(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "i386")
+            set(_ARCH ia32)
+        endif()
+    endif()
+
+    # check whether setvars.sh is sourced
+    if(NOT IE_ROOT_DIR AND (DEFINED ENV{InferenceEngine_DIR} OR InferenceEngine_DIR OR DEFINED ENV{INTEL_CVSDK_DIR}))
+        if (EXISTS "${InferenceEngine_DIR}")
+            # InferenceEngine_DIR manually set via command line params
+            set(IE_ROOT_DIR "${InferenceEngine_DIR}/..")
+        elseif (EXISTS "$ENV{InferenceEngine_DIR}")
+            # InferenceEngine_DIR manually set via env
+            set(IE_ROOT_DIR "$ENV{InferenceEngine_DIR}/..")
+        elseif (EXISTS "$ENV{INTEL_CVSDK_DIR}/inference_engine")
+            # if we installed DL SDK
+            set(IE_ROOT_DIR "$ENV{INTEL_CVSDK_DIR}/inference_engine")
+        elseif (EXISTS "$ENV{INTEL_CVSDK_DIR}/deployment_tools/inference_engine")
+            # CV SDK is installed
+            set(IE_ROOT_DIR "$ENV{INTEL_CVSDK_DIR}/deployment_tools/inference_engine")
+        endif()
+    endif()
+
+    if(IE_ROOT_DIR)
+        if (WIN32)
+            set(_OS_PATH "")
+        else()
+           if (NOT EXISTS "/etc/lsb-release")
+                execute_process(COMMAND find /etc/ -maxdepth 1 -type f -name *-release -exec cat {} \;
+                            OUTPUT_VARIABLE release_data RESULT_VARIABLE result)
+                set(name_regex "NAME=\"([^ \"\n]*).*\"\n")
+                set(version_regex "VERSION=\"([0-9]+(\\.[0-9]+)?)[^\n]*\"")
+            else()
+                #linux version detection using cat /etc/lsb-release
+                file(READ "/etc/lsb-release" release_data)
+                set(name_regex "DISTRIB_ID=([^ \n]*)\n")
+                set(version_regex "DISTRIB_RELEASE=([0-9]+(\\.[0-9]+)?)")
+            endif()
+
+            string(REGEX MATCH ${name_regex} name ${release_data})
+            set(os_name ${CMAKE_MATCH_1})
+
+            string(REGEX MATCH ${version_regex} version ${release_data})
+            set(os_name "${os_name} ${CMAKE_MATCH_1}")
+
+            if (NOT os_name)
+                message(FATAL_ERROR "Cannot detect OS via reading /etc/*-release:\n ${release_data}")
+            endif()
+
+            message (STATUS "/etc/*-release distrib: ${os_name}")
+
+            if (${os_name} STREQUAL "Ubuntu 14.04")
+                set(_OS_PATH "ubuntu_14.04/")
+            elseif (${os_name} STREQUAL "Ubuntu 16.04")
+                set(_OS_PATH "ubuntu_16.04/")
+            elseif (${os_name} STREQUAL "CentOS 7")
+                set(_OS_PATH "centos_7.4/")
+            elseif (${os_name} STREQUAL "poky 2.0")
+                set(_OS_PATH "ubuntu_16.04/")
+            else()
+                message(FATAL_ERROR "${os_name} is not supported. List of supported OS: Ubuntu 14.04, Ubuntu 16.04, CentOS 7")
+            endif()
+        endif()
+    endif()
+
+    if(IE_INCLUDE_DIR AND NOT "${IE_ROOT_DIR}/include" EQUAL "${IE_INCLUDE_DIR}")
+        unset(IE_INCLUDE_DIR CACHE)
+    endif()
+
+    if(IE_LIBRARY AND NOT "${IE_ROOT_DIR}/lib/${_OS_PATH}/${_ARCH}" EQUAL "${IE_LIBRARY}")
+        unset(IE_LIBRARY CACHE)
+    endif()
+
+    set(_IE_ROOT_INCLUDE_DIR "${IE_ROOT_DIR}/include")
+    set(_IE_ROOT_LIBRARY "${IE_ROOT_DIR}/lib/${_OS_PATH}/${_ARCH}")
+    
+
+    find_path(IE_INCLUDE_DIR inference_engine.hpp "${_IE_ROOT_INCLUDE_DIR}")
+    #message("InferenceEngine_INCLUDE_DIR=${IE_INCLUDE_DIR}:${_IE_ROOT_INCLUDE_DIR}")
+
+    include(FindPackageHandleStandardArgs)
+    if (WIN32)
+        find_library(IE_RELEASE_LIBRARY inference_engine "${_IE_ROOT_LIBRARY}/Release")
+        find_library(IE_DEBUG_LIBRARY inference_engine "${_IE_ROOT_LIBRARY}/Debug")
+        find_package_handle_standard_args(  IE
+                                            REQUIRED_VARS IE_RELEASE_LIBRARY IE_DEBUG_LIBRARY IE_INCLUDE_DIR
+                                            FAIL_MESSAGE "Inference Engine cannot be found at ${_IE_ROOT_LIBRARY}. Please consult InferenceEgnineConfig.cmake module's help page.")
+    else()
+        find_library(IE_LIBRARY inference_engine "${_IE_ROOT_LIBRARY}")
+        find_package_handle_standard_args(  IE
+                                            REQUIRED_VARS IE_LIBRARY IE_INCLUDE_DIR
+                                            FAIL_MESSAGE "Inference Engine cannot be found at ${_IE_ROOT_LIBRARY}. Please consult InferenceEgnineConfig.cmake module's help page.")
+    endif()
+    if(IE_FOUND)
+        add_library(IE::inference_engine SHARED IMPORTED GLOBAL)
+
+        if (WIN32)
+            set_property(TARGET IE::inference_engine APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
+            set_property(TARGET IE::inference_engine APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
+
+            set_target_properties(IE::inference_engine PROPERTIES
+                    IMPORTED_IMPLIB_RELEASE    "${IE_RELEASE_LIBRARY}"
+                    IMPORTED_IMPLIB_DEBUG      "${IE_DEBUG_LIBRARY}"
+                    MAP_IMPORTED_CONFIG_DEBUG Debug
+                    MAP_IMPORTED_CONFIG_RELEASE Release
+                    MAP_IMPORTED_CONFIG_RELWITHDEBINFO Release
+                    INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}")
+        else()
+            set_target_properties(IE::inference_engine PROPERTIES
+                    IMPORTED_LOCATION "${IE_LIBRARY}"
+                    INTERFACE_INCLUDE_DIRECTORIES "${IE_INCLUDE_DIR}")
+            target_link_libraries(IE::inference_engine INTERFACE ${CMAKE_DL_LIBS})
+        endif()
+
+        set(InferenceEngine_INCLUDE_DIRS ${IE_INCLUDE_DIR})
+        set(InferenceEngine_LIBRARIES IE::inference_engine)
+        set(InferenceEngine_FOUND TRUE)
+    endif()
+endif()
+

inference-engine/cmake/version.cmake

@@ -0,0 +1,46 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+cmake_minimum_required(VERSION 2.8)
+
+function (branchName VAR)
+    execute_process(
+            COMMAND git rev-parse --abbrev-ref HEAD
+            WORKING_DIRECTORY ${IE_MAIN_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_BRANCH
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+    set (${VAR} ${GIT_BRANCH} PARENT_SCOPE)
+endfunction()
+
+function (commitHash VAR)
+    execute_process(
+            COMMAND git rev-parse HEAD
+            WORKING_DIRECTORY ${IE_MAIN_SOURCE_DIR}
+            OUTPUT_VARIABLE GIT_COMMIT_HASH
+            OUTPUT_STRIP_TRAILING_WHITESPACE)
+    set (${VAR} ${GIT_COMMIT_HASH} PARENT_SCOPE)
+endfunction()
+
+if (DEFINED ENV{CI_BUILD_NUMBER})
+    set(CI_BUILD_NUMBER $ENV{CI_BUILD_NUMBER})
+else()
+    branchName(GIT_BRANCH)
+    commitHash(GIT_COMMIT_HASH)
+
+    set(custom_build "custom_${GIT_BRANCH}_${GIT_COMMIT_HASH}")
+    set(CI_BUILD_NUMBER "${custom_build}")
+endif()
+
+function (addVersionDefines FILE)
+    foreach (VAR ${ARGN})
+        if (DEFINED ${VAR} AND NOT "${${VAR}}" STREQUAL "")
+            set_property(
+                SOURCE ${FILE}
+                APPEND
+                PROPERTY COMPILE_DEFINITIONS
+                ${VAR}="${${VAR}}")
+        endif()
+    endforeach()
+endfunction()

inference-engine/ie_bridges/python/CMakeLists.txt

@@ -0,0 +1,42 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+# Defines the CMake commands/policies
+cmake_minimum_required( VERSION 2.8.5 )
+
+# Set the project name
+project( INFERENCE_ENGINE_DRIVER )
+
+option(COPY_IE_LIBS "Copy Inference Engine libs to package directory" ${WIN32})
+
+set (IE_DEFAULT_PATH computer_vision_sdk/deployment_tools/inference_engine/share)
+
+find_package(InferenceEngine REQUIRED PATHS /opt/intel/${IE_DEFAULT_PATH} $ENV{HOME}/intel/${IE_DEFAULT_PATH})
+
+# Make the scripts available in the 'cmake' directory available for the
+# 'include()' command, 'find_package()' command.
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_LIST_DIR}/cmake )
+
+# Include the CMake script UseCython.cmake.  This defines add_cython_module().
+# Instruction for use can be found at the top of cmake/UseCython.cmake.
+include( UseCython )
+
+# With CMake, a clean separation can be made between the source tree and the
+# build tree.  When all source is compiled, as with pure C/C++, the source is
+# no-longer needed in the build tree.  However, with pure *.py source, the
+# source is processed directly.  To handle this, we reproduce the availability
+# of the source files in the build tree.
+add_custom_target( ReplicatePythonSourceTree ALL ${CMAKE_COMMAND} -P
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/ReplicatePythonSourceTree.cmake
+  ${CMAKE_CURRENT_BINARY_DIR}
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
+
+add_custom_target( CopyIeLibs ${CMAKE_COMMAND} -P
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/CopyIeLibs.cmake
+  ${IE_ROOT_DIR}/bin/${_ARCH}/Release ${_IE_ROOT_LIBRARY}
+  WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/ie_driver )
+
+include_directories( IE::inference_engine )
+
+# Process the CMakeLists.txt in the 'src' and 'bin' directory.
+add_subdirectory( inference_engine )

inference-engine/ie_bridges/python/README.md

@@ -0,0 +1,39 @@
+## Software Requirements
+- [CMake\*](https://cmake.org/download/) 3.9 or later
+- Microsoft\* Visual Studio 2015 or later on Windows\*
+- gcc 4.8 or later on Linux
+- Python 2.7 or higher on Linux\*
+- Python 3.4 or higher on Windows\*
+
+## Prerequisites
+
+Install the following Python modules:
+- opencv-python
+- numpy
+- cython
+
+## Building on Windows
+```shellscript
+	mkdir build
+	cd build
+	set PATH=C:\Program Files\Python36\Scripts;%PATH%
+	cmake -G "Visual Studio 14 2015 Win64" -DInferenceEngine_DIR=..\..\..\build ^
+		-DPYTHON_EXECUTABLE="C:\Program Files\Python36\python.exe" ^
+		-DPYTHON_INCLUDE_DIR="C:\Program Files\Python36\include" ^
+		-DPYTHON_LIBRARY="C:\Program Files\Python36\libs\python36.lib" ..
+```
+
+Then build generated solution INFERENCE_ENGINE_DRIVER.sln using Microsoft\* Visual Studio.
+
+## Building on Linux
+
+```shellscript
+  mkdir -p build
+  cd build
+  cmake -DInferenceEngine_DIR=../../../build -DPYTHON_EXECUTABLE=`which python3.6` \
+  	-DPYTHON_LIBRARY=/usr/lib/x86_64-linux-gnu/libpython3.6m.so \
+  	-DPYTHON_INCLUDE_DIR=/usr/include/python3.6 ..
+  make -j16
+```
+
+Note: -DInferenceEngine_DIR parameter is needed to specify the folder with generated make files or Visual Studio solution used to build Inference Engine (see readme file in the inference-engine root folder).

inference-engine/ie_bridges/python/cmake/CopyIeLibs.cmake

@@ -0,0 +1,10 @@
+set(IE_WIN_LIBS ${CMAKE_ARGV3})
+set(IE_LIBS ${CMAKE_ARGV4})
+
+if (WIN32)
+    file( GLOB IE_LIBS "${IE_WIN_LIBS}/*.dll")
+    file( COPY ${IE_LIBS} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR})
+else()
+    file( GLOB IE_LIBS "${IE_LIBS}/*.so")
+    file( COPY ${IE_LIBS} DESTINATION ${CMAKE_CURRENT_SOURCE_DIR})
+endif()

inference-engine/ie_bridges/python/cmake/FindCython.cmake

@@ -0,0 +1,44 @@
+# Find the Cython compiler.
+#
+# This code sets the following variables:
+#
+#  CYTHON_EXECUTABLE
+#
+# See also UseCython.cmake
+
+#=============================================================================
+# Copyright 2011 Kitware, Inc.
+#
+# 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.
+#=============================================================================
+
+# Use the Cython executable that lives next to the Python executable
+# if it is a local installation.
+find_package( PythonInterp )
+if( PYTHONINTERP_FOUND )
+  get_filename_component( _python_path ${PYTHON_EXECUTABLE} PATH )
+  find_program( CYTHON_EXECUTABLE
+    NAMES cython cython.bat cython3
+    HINTS ${_python_path} $ENV{HOME}/.local/bin
+    )
+else()
+  find_program( CYTHON_EXECUTABLE
+    NAMES cython cython.bat cython3
+    )
+endif()
+
+
+include( FindPackageHandleStandardArgs )
+FIND_PACKAGE_HANDLE_STANDARD_ARGS( Cython REQUIRED_VARS CYTHON_EXECUTABLE )
+
+mark_as_advanced( CYTHON_EXECUTABLE )

inference-engine/ie_bridges/python/cmake/ReplicatePythonSourceTree.cmake

@@ -0,0 +1,7 @@
+# Note: when executed in the build dir, then CMAKE_CURRENT_SOURCE_DIR is the
+# build dir.
+
+file( COPY setup.py inference_engine tests DESTINATION "${CMAKE_ARGV3}"
+  FILES_MATCHING PATTERN "*.py" )
+
+file( COPY requirements.txt DESTINATION "${CMAKE_ARGV3}" )

inference-engine/ie_bridges/python/cmake/UseCython.cmake

@@ -0,0 +1,319 @@
+# Define a function to create Cython modules.
+#
+# For more information on the Cython project, see http://cython.org/.
+# "Cython is a language that makes writing C extensions for the Python language
+# as easy as Python itself."
+#
+# This file defines a CMake function to build a Cython Python module.
+# To use it, first include this file.
+#
+#   include( UseCython )
+#
+# Then call cython_add_module to create a module.
+#
+#   cython_add_module( <module_name> <src1> <src2> ... <srcN> )
+#
+# To create a standalone executable, the function
+#
+#   cython_add_standalone_executable( <executable_name> [MAIN_MODULE src1] <src1> <src2> ... <srcN> )
+#
+# To avoid dependence on Python, set the PYTHON_LIBRARY cache variable to point
+# to a static library.  If a MAIN_MODULE source is specified,
+# the "if __name__ == '__main__':" from that module is used as the C main() method
+# for the executable.  If MAIN_MODULE, the source with the same basename as
+# <executable_name> is assumed to be the MAIN_MODULE.
+#
+# Where <module_name> is the name of the resulting Python module and
+# <src1> <src2> ... are source files to be compiled into the module, e.g. *.pyx,
+# *.py, *.c, *.cxx, etc.  A CMake target is created with name <module_name>.  This can
+# be used for target_link_libraries(), etc.
+#
+# The sample paths set with the CMake include_directories() command will be used
+# for include directories to search for *.pxd when running the Cython complire.
+#
+# Cache variables that effect the behavior include:
+#
+#  CYTHON_ANNOTATE
+#  CYTHON_NO_DOCSTRINGS
+#  CYTHON_FLAGS
+#
+# Source file properties that effect the build process are
+#
+#  CYTHON_IS_CXX
+#
+# If this is set of a *.pyx file with CMake set_source_files_properties()
+# command, the file will be compiled as a C++ file.
+#
+# See also FindCython.cmake
+
+#=============================================================================
+# Copyright 2011 Kitware, Inc.
+#
+# 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.
+#=============================================================================
+
+# Configuration options.
+set( CYTHON_ANNOTATE OFF
+  CACHE BOOL "Create an annotated .html file when compiling *.pyx." )
+set( CYTHON_NO_DOCSTRINGS OFF
+  CACHE BOOL "Strip docstrings from the compiled module." )
+set( CYTHON_FLAGS "" CACHE STRING
+  "Extra flags to the cython compiler." )
+mark_as_advanced( CYTHON_ANNOTATE CYTHON_NO_DOCSTRINGS CYTHON_FLAGS )
+
+find_package( Cython REQUIRED )
+find_package( PythonLibs REQUIRED )
+
+set( CYTHON_CXX_EXTENSION "cxx" )
+set( CYTHON_C_EXTENSION "c" )
+
+# Create a *.c or *.cxx file from a *.pyx file.
+# Input the generated file basename.  The generate file will put into the variable
+# placed in the "generated_file" argument. Finally all the *.py and *.pyx files.
+function( compile_pyx _name generated_file )
+  # Default to assuming all files are C.
+  set( cxx_arg "" )
+  set( extension ${CYTHON_C_EXTENSION} )
+  set( pyx_lang "C" )
+  set( comment "Compiling Cython C source for ${_name}..." )
+
+  set( cython_include_directories "" )
+  set( pxd_dependencies "" )
+  set( pxi_dependencies "" )
+  set( c_header_dependencies "" )
+  set( pyx_locations "" )
+
+  foreach( pyx_file ${ARGN} )
+    get_filename_component( pyx_file_basename "${pyx_file}" NAME_WE )
+
+    # Determine if it is a C or C++ file.
+    get_source_file_property( property_is_cxx ${pyx_file} CYTHON_IS_CXX )
+    if( ${property_is_cxx} )
+      set( cxx_arg "--cplus" )
+      set( extension ${CYTHON_CXX_EXTENSION} )
+      set( pyx_lang "CXX" )
+      set( comment "Compiling Cython CXX source for ${_name}..." )
+    endif()
+
+    # Get the include directories.
+    get_source_file_property( pyx_location ${pyx_file} LOCATION )
+    get_filename_component( pyx_path ${pyx_location} PATH )
+    get_directory_property( cmake_include_directories DIRECTORY ${pyx_path} INCLUDE_DIRECTORIES )
+    list( APPEND cython_include_directories ${cmake_include_directories} )
+    list( APPEND pyx_locations "${pyx_location}" )
+
+    # Determine dependencies.
+    # Add the pxd file will the same name as the given pyx file.
+    unset( corresponding_pxd_file CACHE )
+    find_file( corresponding_pxd_file ${pyx_file_basename}.pxd
+      PATHS "${pyx_path}" ${cmake_include_directories}
+      NO_DEFAULT_PATH )
+    if( corresponding_pxd_file )
+      list( APPEND pxd_dependencies "${corresponding_pxd_file}" )
+    endif()
+
+    # Look for included pxi files
+    file(STRINGS "${pyx_file}" include_statements REGEX "include +['\"]([^'\"]+).*")
+    foreach(statement ${include_statements})
+      string(REGEX REPLACE "include +['\"]([^'\"]+).*" "\\1" pxi_file "${statement}")
+      unset(pxi_location CACHE)
+      find_file(pxi_location ${pxi_file}
+        PATHS "${pyx_path}" ${cmake_include_directories} NO_DEFAULT_PATH)
+      if (pxi_location)
+        list(APPEND pxi_dependencies ${pxi_location})
+        get_filename_component( found_pyi_file_basename "${pxi_file}" NAME_WE )
+        get_filename_component( found_pyi_path ${pxi_location} PATH )
+        unset( found_pyi_pxd_file CACHE )
+        find_file( found_pyi_pxd_file ${found_pyi_file_basename}.pxd
+          PATHS "${found_pyi_path}" ${cmake_include_directories} NO_DEFAULT_PATH )
+        if (found_pyi_pxd_file)
+            list( APPEND pxd_dependencies "${found_pyi_pxd_file}" )
+        endif()
+      endif()
+    endforeach() # for each include statement found
+
+    # pxd files to check for additional dependencies.
+    set( pxds_to_check "${pyx_file}" "${pxd_dependencies}" )
+    set( pxds_checked "" )
+    set( number_pxds_to_check 1 )
+    while( ${number_pxds_to_check} GREATER 0 )
+      foreach( pxd ${pxds_to_check} )
+        list( APPEND pxds_checked "${pxd}" )
+        list( REMOVE_ITEM pxds_to_check "${pxd}" )
+
+        # check for C header dependencies
+        file( STRINGS "${pxd}" extern_from_statements
+          REGEX "cdef[ ]+extern[ ]+from.*$" )
+        foreach( statement ${extern_from_statements} )
+          # Had trouble getting the quote in the regex
+          string( REGEX REPLACE "cdef[ ]+extern[ ]+from[ ]+[\"]([^\"]+)[\"].*" "\\1" header "${statement}" )
+          unset( header_location CACHE )
+          find_file( header_location ${header} PATHS ${cmake_include_directories} )
+          if( header_location )
+            list( FIND c_header_dependencies "${header_location}" header_idx )
+            if( ${header_idx} LESS 0 )
+              list( APPEND c_header_dependencies "${header_location}" )
+            endif()
+          endif()
+        endforeach()
+
+        # check for pxd dependencies
+
+        # Look for cimport statements.
+        set( module_dependencies "" )
+        file( STRINGS "${pxd}" cimport_statements REGEX cimport )
+        foreach( statement ${cimport_statements} )
+          if( ${statement} MATCHES from )
+            string( REGEX REPLACE "from[ ]+([^ ]+).*" "\\1" module "${statement}" )
+          else()
+            string( REGEX REPLACE "cimport[ ]+([^ ]+).*" "\\1" module "${statement}" )
+          endif()
+          list( APPEND module_dependencies ${module} )
+        endforeach()
+        list( REMOVE_DUPLICATES module_dependencies )
+        # Add the module to the files to check, if appropriate.
+        foreach( module ${module_dependencies} )
+          unset( pxd_location CACHE )
+          find_file( pxd_location ${module}.pxd
+            PATHS "${pyx_path}" ${cmake_include_directories} NO_DEFAULT_PATH )
+          if( pxd_location )
+            list( FIND pxds_checked ${pxd_location} pxd_idx )
+            if( ${pxd_idx} LESS 0 )
+              list( FIND pxds_to_check ${pxd_location} pxd_idx )
+              if( ${pxd_idx} LESS 0 )
+                list( APPEND pxds_to_check ${pxd_location} )
+                list( APPEND pxd_dependencies ${pxd_location} )
+              endif() # if it is not already going to be checked
+            endif() # if it has not already been checked
+          endif() # if pxd file can be found
+        endforeach() # for each module dependency discovered
+      endforeach() # for each pxd file to check
+      list( LENGTH pxds_to_check number_pxds_to_check )
+    endwhile()
+
+
+
+  endforeach() # pyx_file
+
+  # Set additional flags.
+  if( CYTHON_ANNOTATE )
+    set( annotate_arg "--annotate" )
+  endif()
+
+  if( CYTHON_NO_DOCSTRINGS )
+    set( no_docstrings_arg "--no-docstrings" )
+  endif()
+
+  if( "${CMAKE_BUILD_TYPE}" STREQUAL "Debug" OR
+        "${CMAKE_BUILD_TYPE}" STREQUAL "RelWithDebInfo" )
+      set( cython_debug_arg "--gdb" )
+  endif()
+
+  if( "${PYTHONLIBS_VERSION_STRING}" MATCHES "^2." )
+    set( version_arg "-2" )
+  elseif( "${PYTHONLIBS_VERSION_STRING}" MATCHES "^3." )
+    set( version_arg "-3" )
+  else()
+    set( version_arg )
+  endif()
+
+  # Include directory arguments.
+  list( REMOVE_DUPLICATES cython_include_directories )
+  set( include_directory_arg "" )
+  foreach( _include_dir ${cython_include_directories} )
+    set( include_directory_arg ${include_directory_arg} "-I" "${_include_dir}" )
+  endforeach()
+
+  # Determining generated file name.
+  set( _generated_file "${CMAKE_CURRENT_BINARY_DIR}/${_name}.${extension}" )
+  set_source_files_properties( ${_generated_file} PROPERTIES GENERATED TRUE )
+  set( ${generated_file} ${_generated_file} PARENT_SCOPE )
+
+  list( REMOVE_DUPLICATES pxd_dependencies )
+  list( REMOVE_DUPLICATES c_header_dependencies )
+
+  # Add the command to run the compiler.
+  add_custom_command( OUTPUT ${_generated_file}
+    COMMAND ${CYTHON_EXECUTABLE}
+    ARGS ${cxx_arg} ${include_directory_arg} ${version_arg}
+    ${annotate_arg} ${no_docstrings_arg} ${cython_debug_arg} ${CYTHON_FLAGS}
+    --output-file  ${_generated_file} ${pyx_locations}
+    DEPENDS ${pyx_locations} ${pxd_dependencies} ${pxi_dependencies}
+    IMPLICIT_DEPENDS ${pyx_lang} ${c_header_dependencies}
+    COMMENT ${comment}
+    )
+
+  # Remove their visibility to the user.
+  set( corresponding_pxd_file "" CACHE INTERNAL "" )
+  set( header_location "" CACHE INTERNAL "" )
+  set( pxd_location "" CACHE INTERNAL "" )
+endfunction()
+
+# cython_add_module( <name> src1 src2 ... srcN )
+# Build the Cython Python module.
+function( cython_add_module _name )
+  set( pyx_module_sources "" )
+  set( other_module_sources "" )
+  foreach( _file ${ARGN} )
+    if( ${_file} MATCHES ".*\\.py[x]?$" )
+      list( APPEND pyx_module_sources ${_file} )
+    else()
+      list( APPEND other_module_sources ${_file} )
+    endif()
+  endforeach()
+  compile_pyx( ${_name} generated_file ${pyx_module_sources} )
+  include_directories( ${PYTHON_INCLUDE_DIRS} )
+  python_add_module( ${_name} ${generated_file} ${other_module_sources} )
+  if( APPLE )
+    set_target_properties( ${_name} PROPERTIES LINK_FLAGS "-undefined dynamic_lookup" )
+  else()
+    target_link_libraries( ${_name} PRIVATE ${PYTHON_LIBRARIES} )
+  endif()
+endfunction()
+
+include( CMakeParseArguments )
+# cython_add_standalone_executable( _name [MAIN_MODULE src3.py] src1 src2 ... srcN )
+# Creates a standalone executable the given sources.
+function( cython_add_standalone_executable _name )
+  set( pyx_module_sources "" )
+  set( other_module_sources "" )
+  set( main_module "" )
+  cmake_parse_arguments( cython_arguments "" "MAIN_MODULE" "" ${ARGN} )
+  include_directories( ${PYTHON_INCLUDE_DIRS} )
+  foreach( _file ${cython_arguments_UNPARSED_ARGUMENTS} )
+    if( ${_file} MATCHES ".*\\.py[x]?$" )
+      get_filename_component( _file_we ${_file} NAME_WE )
+      if( "${_file_we}" STREQUAL "${_name}" )
+        set( main_module "${_file}" )
+      elseif( NOT "${_file}" STREQUAL "${cython_arguments_MAIN_MODULE}" )
+        set( PYTHON_MODULE_${_file_we}_static_BUILD_SHARED OFF )
+        compile_pyx( "${_file_we}_static" generated_file "${_file}" )
+        list( APPEND pyx_module_sources "${generated_file}" )
+      endif()
+    else()
+      list( APPEND other_module_sources ${_file} )
+    endif()
+  endforeach()
+
+  if( cython_arguments_MAIN_MODULE )
+    set( main_module ${cython_arguments_MAIN_MODULE} )
+  endif()
+  if( NOT main_module )
+    message( FATAL_ERROR "main module not found." )
+  endif()
+  get_filename_component( main_module_we "${main_module}" NAME_WE )
+  set( CYTHON_FLAGS ${CYTHON_FLAGS} --embed )
+  compile_pyx( "${main_module_we}_static" generated_file ${main_module} )
+  add_executable( ${_name} ${generated_file} ${pyx_module_sources} ${other_module_sources} )
+  target_link_libraries( ${_name} PRIVATE ${PYTHON_LIBRARIES} ${pyx_module_libs} )
+endfunction()

inference-engine/ie_bridges/python/docs/api_overview.md

@@ -0,0 +1,516 @@
+# Overview of Inference Engine Python* API {#InferEnginePythonAPI}
+
+**NOTE:** It is a preview version of the Inference Engine Python\* API for evaluation purpose only. 
+Module structure and API itself may be changed in future releases.  
+
+This API provides a simplified interface for Inference Engine functionality that allows to:
+
+* handle the models
+* load and configure Inference Engine plugins based on device names
+* perform inference in synchronous and asynchronous modes with arbitrary number of infer requests (the number of infer requests may be limited by target device capabilities)
+
+## Supported OSes
+
+Currently the Inference Engine Python\* API is supported on Ubuntu* 16.04, Microsoft Windows* 10 and CentOS* 7.3 OSes.   
+Supported Python* versions:  
+
+* On Ubuntu 16.04: 2.7, 3.5, 3.6  
+* On Windows 10: 3.5, 3.6
+* On CentOS 7.3: 3.4, 3.5, 3.6
+
+## Setting Up the Environment
+
+To configure the environment for the Inference Engine Python\* API, run:
+ * On Ubuntu 16.04: `source <INSTALL_DIR>/bin/setupvars.sh .` 
+ * On Windows 10: `call <INSTALL_DIR>\deployment_tools\inference_engine\python_api\setenv.bat`
+ 
+The script automatically detects latest installed Python\* version and configures required environment if the version is supported.  
+If you want to use certain version of Python\*, set the environment variable `PYTHONPATH=<INSTALL_DIR>/deployment_tools/inference_engine/python_api/<desired_python_version>`
+after running the environment configuration script.
+   
+## <a name="ienetlayer-class"></a>IENetLayer
+This class stores main information about the layer and allow to modify some layer parameters 
+### Class attributes:
+ 
+* `name` - name of the layer 
+* `type` - layer type
+* `precision` - layer base operating precision
+* `affinity` - layer affinity set by user or default affinity set by IEPlugin.set_initial_affinity() method.             
+             The affinity attribute provides getter and setter interface, so the layer affinity can be modified directly in following way
+             
+```py
+    >>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+    >>> plugin = IEPlugin(device="HETERO:FPGA,CPU")
+    >>> plugin.set_config({"TARGET_FALLBACK": "HETERO:FPGA,CPU"})
+    >>> plugin.set_initial_affinity(net) 
+    >>> for l in net.layers.values():
+    ...     if l.type == "Convolution":
+    ...         l.affinity = "CPU"
+
+```
+		
+To correctly set affinity for the network, you must first initialize and properly configure the HETERO plugin. 
+`set_config({"TARGET_FALLBACK": "HETERO:FPGA,GPU"})` function configures the plugin fallback devices and their order. 
+`plugin.set_initial_affinity(net)` function sets affinity parameter of model layers according to its support 
+on specified devices. 
+
+After default affinity is set by the plugin, override the default values by setting affinity manually how it's 
+described in example above  
+
+To understand how default and non-default affinities are set: 
+
+1. Call `net.layers` function right after model loading and check that layer affinity parameter is empty.
+2. Call `plugin.set_default_affinity(net)`.
+3. Call `net.layers` and check layer affinity parameters to see how plugin set default affinity
+4. Set layer affinity how it's described above
+5. Call `net.layers` again and check layer affinity parameters to see how it was changed after manual affinity 
+   setting
+          
+Please refer to `affinity_setting_sample.py` to see the full usage pipeline.
+    
+* `weights` - dictionary with layer weights, biases or custom blobs if any
+* `params` - layer specific parameters. Provides getter and setter interface which allows to get and\or modify layer parameters.
+            Please note that some modifications can be ignored and\or overwriten by target plugin (e.g. modification of 
+            convolution kernel size will be reflected in layer parameters but finally the plugin will ignore it and will
+            use initial kernel size) 
+
+## <a name="ienetwork-class"></a>IENetwork 
+
+This class contains the information about the network model read from IR and allows you to manipulate with some model parameters such as
+layers affinity and output layers.
+
+### Class Constructor
+
+There is no explicit class constructor. Use `from_ir` class method to read the Intermediate Representation (IR) and initialize a correct instance of the `IENetwork` class.
+
+### Class attributes:
+
+* `name` - Name of the loaded network
+* `inputs` - a dictionary of input layer name as a key and input data shape as a value
+
+    * Usage example:
+    ```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> net.inputs
+		{'data': [1, 3, 224, 224]}
+    ```
+* `outputs` - a list of output layer names
+
+    * Usage example:
+    ```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> net.outputs
+		['prob']
+    ```
+    
+* `batch_size` - Batch size of the network. Provides getter and setter interface which allows to get and modify the 
+                 network batch size in the following way:
+    ```py
+    >>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+    >>> net.batch_size
+    1
+    >>> net.batch_size = 4
+    >>> net.batch_size
+    4
+    ```
+* `layers` - return dictionary with the network layer names as key and <a name="ienetlayer-class"></a>IENetLayer objects containing layer properties 
+             as value
+             
+    ```py
+		 >>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		 >>> net.layers
+		 {'conv0': <inference_engine.ie_api.IENetLayer object at 0x7f3a4c102370>}
+		 ```
+### Class Methods
+
+* `from_ir(model: str, weights: str)` 
+
+    * Description:
+            
+        The class method serves to read the model from the `.xml` and `.bin` files of the IR.
+		
+    * Parameters:
+        
+        * model - path to `.xml` file  of the IR
+        * weights - path to `.bin` file  of the IR
+    
+    * Return value:
+            
+        An instance of the `IENetwork` class
+            
+    * Usage example:
+		```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> net
+		<inference_engine.ie_api.IENetwork object at 0x7fd7dbce54b0>
+		```
+            
+### Instance Methods
+	 
+* `add_outputs(outputs)`:
+
+    * Description:
+                
+        The method serves to mark any intermediate layer as output layer to retrieve the inference results 
+        from the specified layers.
+		
+    * Parameters:
+            
+        * `outputs` - a list of layer names to be set as model outputs. In case of setting one layer as output, string with one layer can be provided.
+            
+    * Return value:
+    
+        None
+            
+    * Usage example:
+		```py
+        >>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+        >>> net.add_outputs(["conv5_1/dwise', conv2_1/expand'])]
+        >>> net.outputs
+        ['prob', 'conv5_1/dwise', 'conv2_1/expand']
+        ```  
+		
+        Note that the last layers (nodes without successors in graph representation of the model) are set as output 
+        by default. In the case above, `prob` layer is a default output and `conv5_1/dwise`, `conv2_1/expand` are user-defined
+		outputs. 
+
+## <a name="ieplugin-class"></a>IEPlugin Class
+
+This class is the main plugin interface and serves to initialize and configure the plugin.
+ 
+### Class Constructor
+
+* `__init__(device: str, plugin_dirs=None)`
+
+    * Parameters:
+    
+        * `device` - target device name. Supported devices: CPU, GPU, FPGA, MYRIAD, HETERO
+        * `plugin_dirs` - list of paths to plugin directories 
+        
+### Properties
+
+* `device` - a name of the device that was specified to initialize IEPlugin
+* `version` -  a version of the plugin 
+
+### Instance Methods
+
+*  `load(network: IENetwork, num_requests: int=1, config=None)`
+
+    * Description:
+        
+        Loads a network that was read from the IR to the plugin and creates an executable network from a network object. 
+        You can create as many networks as you need and use them simultaneously (up to the limitation of the hardware 
+        resources).
+    
+    * Parameters:
+	
+        * `network` - a valid IENetwork instance created by `IENetwork.from_ir()` method
+        * `num_requests` - a positive integer value of infer requests to be created. Number of infer requests may be limited 
+        by device capabilities.        
+        * `config` - a dictionary of plugin configuration keys and their values
+        
+    * Return value:
+        
+        None
+    
+    * Usage example:
+		```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> plugin = IEPlugin(device="CPU")
+		>>> exec_net = plugin.load(network=net, num_requsts=2)
+		>>> exec_net
+		<inference_engine.ie_api.ExecutableNetwork object at 0x7f5140bbcd38>
+		```
+* `set_initial_affinity(net: IENetwork)`
+    
+    * Description:
+        
+        Sets initial affinity for model layers according to the HETERO plugin logic. Applicable only if 
+        IEPlugin was initialized for HETERO device.
+        
+    * Parameters:
+	
+        * `net` - a valid instance of IENetwork 
+    
+    * Return value:
+        
+        None
+        
+    * Usage example: 
+	
+		See `affinity` attribute of the `IENetLayer` class.
+    
+* `add_cpu_extension(extension_path: str)`
+
+    * Description:
+        
+        Loads extensions library to the plugin. Applicable only for CPU device and HETERO device with CPU
+        
+    * Parameters:
+    
+        * `extension_path` - a full path to CPU extensions library   
+        
+     * Return value:
+        
+        None
+        
+    * Usage example:
+		```py
+		>>> plugin = IEPlugin(device="CPU")
+		>>> plugin.add_cpu_extenstions(ext_lib_path)
+		```
+* `set_config(config: dict)`
+
+    * Description: 
+     
+        Sets a configuration for the plugin. Refer to `SetConfig()` in Inference Engine C++ documentation for acceptable 
+        keys and values list.
+        
+    * Parameters: 
+        
+        * `config` - a dictionary of keys and values of acceptable configuration parameters
+        
+    * Return value:
+        
+        None
+    
+    * Usage examples: 
+		
+		See `set_affinity` method of the `IENetwork` class.
+
+* `get_supported_layers(net: IENetwork)`
+    * Description:
+        
+        Returns the set of layers supported by the plugin. Please note that in case of CPU plugin support of 
+        a layer may depends on extension loaded by `add_cpu_extenstion()` method 
+        
+    * Parameters:
+	
+        * `net` - a valid instance of IENetwork 
+    
+    * Return value:
+        
+        Set of layers supported by the plugin
+        
+    * Usage example: 
+	
+		See `affinity` attribute of the `IENetLayer` class.
+   
+## <a name="executablenetwork"></a>ExecutableNetwork Class
+
+This class represents a network instance loaded to plugin and ready for inference. 
+
+### Class Constructor
+
+There is no explicit class constructor. To make a valid instance of `ExecutableNetwork`, use `load()` method of the `IEPlugin` class.
+
+### Class attributes
+
+* `requests` - a tuple of InferRequest instances
+
+    * Usage example:
+		```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> plugin = IEPlugin(device="CPU")
+		>>> exec_net = plugin.load(network=net, num_requsts=2)
+		>>> exec_net.requests
+		(<inference_engine.ie_api.InferRequest object at 0x7f66f56c57e0>, <inference_engine.ie_api.InferRequest object at 0x7f66f56c58b8>, <inference_engine.ie_api.InferRequest object at 0x7f66f56c5900>)
+		```
+		
+### Instance Methods
+
+* `infer(inputs=None)`
+
+    * Description:
+        
+        Starts synchronous inference for the first infer request of the executable network and returns output data.
+        Wraps `infer()` method of the `InferRequest` class
+    
+    * Parameters:
+        * `inputs` - a dictionary of input layer name as a key and `numpy.ndarray` of proper shape with input data for the layer as a value
+        
+    * Return value:
+        
+        A dictionary of output layer name as a key and `numpy.ndarray` with output data of the layer as a value
+        
+    * Usage example:
+		```py
+		>>> net = IENetwork.from_ir(model=path_to_xml_file, weights=path_to_bin_file)
+		>>> plugin = IEPlugin(device="CPU")
+		>>> exec_net = plugin.load(network=net, num_requsts=2)
+		>>> res = exec_net.infer({'data': img})
+		>>> res
+		{'prob': array([[[[2.83426580e-08]],
+						 [[2.40166020e-08]],
+						 [[1.29469613e-09]],
+						 [[2.95946148e-08]]
+						 ......
+					  ]])}
+		```
+      For illustration of input data preparation, please see samples (for example, `classification_sample.py`).
+      
+* `start_async(request_id, inputs=None)`
+
+    * Description:
+        
+        Starts asynchronous inference for specified infer request.
+        Wraps `async_infer()` method of the `InferRequest` class
+        
+    * Parameters:
+	
+        * `request_id` - index of infer request to start inference
+        * `inputs` - a dictionary of input layer name as a key and `numpy.ndarray` of proper shape with input data for the layer as a value
+        
+    * Return value:
+        
+        A handler of specified infer request, which is an instance of the `InferRequest` class.
+        
+    * Usage example:
+		```py
+		>>> infer_request_handle = exec_net.start_async(request_id=0, inputs={input_blob: image})
+		>>> infer_status = infer_request_handle.wait()
+		>>> res = infer_request_handle.outputs[out_blob]
+		```
+        For more details about infer requests processing, see `classification_sample_async.py` (simplified case) and 
+        `object_detection_demo_ssd_async.py` (real synchronous use case) samples.
+        
+## <a name="inferrequest"></a>InferRequest Class
+
+This class provides an interface to infer requests of `ExecutableNetwork` and serves to handle infer requests execution
+and to set and get output data.   
+
+### Class Constructor
+
+There is no explicit class constructor. To make a valid `InferRequest` instance, use `load()` method of the `IEPlugin` 
+class with specified number of requests to get `ExecutableNetwork` instance which stores infer requests. 
+
+### Class attributes
+
+* `inputs` - a dictionary of input layer name as a key and `numpy.ndarray` of proper shape with input data for the layer as a value
+* `outputs` - a dictionary of output layer name as a key and `numpy.ndarray` with output data of the layer as a value
+
+* Usage example:
+	```py    
+	>>> exec_net.requests[0].inputs['data'][:] = image
+	>>> exec_net.requests[0].infer()
+	>>> res = exec_net.requests[0].outputs['prob']
+	>>> np.flip(np.sort(np.squeeze(res)),0) 
+	array([4.85416055e-01, 1.70385033e-01, 1.21873841e-01, 1.18894853e-01,
+		   5.45198545e-02, 2.44456064e-02, 5.41366823e-03, 3.42589128e-03,
+		   2.26027006e-03, 2.12283316e-03 ...])
+	``` 
+	
+### Instance Methods
+
+It is not recommended to run inference directly on `InferRequest` instance. 
+To run inference, please use simplified methods `infer()` and `start_async()` of `ExecutableNetwork`. 
+
+* `infer(inputs=None)`
+
+    * Description: 
+    
+         Starts synchronous inference of the infer request and fill outputs array
+		 
+     * Parameters:
+	 
+        * `inputs` - a dictionary of input layer name as a key and `numpy.ndarray` of proper shape with input data for the layer as a value
+        
+    * Return value:
+        
+        None
+        
+    * Usage example:
+		```py
+		>>> exec_net = plugin.load(network=net, num_requests=2)
+		>>> exec_net.requests[0].infer({input_blob: image})
+		>>> res = exec_net.requests[0].outputs['prob']
+		>>> np.flip(np.sort(np.squeeze(res)),0) 
+		array([4.85416055e-01, 1.70385033e-01, 1.21873841e-01, 1.18894853e-01,
+			   5.45198545e-02, 2.44456064e-02, 5.41366823e-03, 3.42589128e-03,
+			   2.26027006e-03, 2.12283316e-03 ...]) 
+		```       
+                   
+* `async_infer(inputs=None)`
+
+    * Description: 
+    
+        Starts asynchronous inference of the infer request and fill outputs array
+		
+     * Parameters:
+	 
+        * `inputs` - a dictionary of input layer name as a key and `numpy.ndarray` of proper shape with input data for the layer as a value
+        
+    * Return value:
+        
+        None
+        
+    * Usage example:
+		```py
+		>>> exec_net = plugin.load(network=net, num_requests=2)
+		>>> exec_net.requests[0].async_infer({input_blob: image})
+		>>> exec_net.requests[0].wait()
+		>>> res = exec_net.requests[0].outputs['prob']
+		>>> np.flip(np.sort(np.squeeze(res)),0) 
+		array([4.85416055e-01, 1.70385033e-01, 1.21873841e-01, 1.18894853e-01,
+			   5.45198545e-02, 2.44456064e-02, 5.41366823e-03, 3.42589128e-03,
+			   2.26027006e-03, 2.12283316e-03 ...]) 
+		```
+			
+* `wait(timeout=-1)`
+
+    * Description:
+        
+        Waits for the result to become available. Blocks until specified timeout elapses or the result 
+        becomes available, whichever comes first. 
+        
+        **Note:**
+        
+        There are special values of the timeout parameter:
+        
+        * 0 - immediately returns the inference status. It does not block or interrupt execution. 
+        To find statuses meaning, please refer to InferenceEngine::StatusCode in Inference Engine C++ documentation
+        
+        * -1 - waits until inference result becomes available (default value)
+        
+    * Parameters:
+	
+        * `timeout` - time to wait in milliseconds or special (0, -1) cases described above. 
+          If not specified, `timeout` value is set to -1 by default.
+      
+    * Usage example: 
+	
+		See `async_infer()` method of the the `InferRequest` class.
+		
+
+* `get_perf_counts()`
+
+    * Description:
+        
+        Queries performance measures per layer to get feedback of what is the most time consuming layer. . 
+        
+        **Note**:
+            
+        Performance counters data and format depends on the plugin
+        
+    * Parameters:
+	
+        None
+      
+    * Usage example: 
+	
+		```py
+		>>> exec_net = plugin.load(network=net, num_requests=2)
+		>>> exec_net.requests[0].infer({input_blob: image})
+		>>> exec_net.requests[0].get_perf_counts()
+        {'Conv2D': {'exec_type': 'jit_avx2_1x1', 
+                    'real_time': 154, 
+                    'cpu_time': 154, 
+                    'status': 'EXECUTED', 
+                    'layer_type': 'Convolution'},
+         'Relu6':  {'exec_type': 'undef', 
+                    'real_time': 0, 
+                    'cpu_time': 0, 
+                    'status': 'NOT_RUN', 
+                    'layer_type': 'Clamp'}
+        ...
+        }

inference-engine/ie_bridges/python/inference_engine/CMakeLists.txt

@@ -0,0 +1,69 @@
+# Copyright (C) 2018 Intel Corporation
+# SPDX-License-Identifier: Apache-2.0
+#
+# If the pyx file is a C++ file, we should specify that here.
+
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+if (COPY_IE_LIBS)
+  if (UNIX)
+    SET(CMAKE_SKIP_BUILD_RPATH  FALSE)
+    SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)
+    SET(CMAKE_INSTALL_RPATH "$ORIGIN")
+    SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH FALSE)
+  endif (UNIX)
+endif()
+
+set_source_files_properties(
+    ie_api_impl_defs.pxd
+    ie_api_impl.hpp
+    ie_api_impl.cpp
+    ie_api.pyx
+    ie_api.pxd
+
+  PROPERTIES CYTHON_IS_CXX TRUE
+)
+
+cython_add_module(
+    ie_api
+
+    ie_api_impl_defs.pxd
+    ie_api_impl.hpp
+    ie_api_impl.cpp
+    ie_api.pyx
+)
+
+target_link_libraries(ie_api PRIVATE IE::inference_engine)
+set_target_properties(ie_api PROPERTIES CXX_STANDARD 11 LINKER_LANGUAGE CXX)
+
+#if (NOT UNIX AND ${PYTHON_VERSION_STRING} MATCHES "^1.4")
+#  set(python_subdir "python2.7")
+#else()
+#  set(python_subdir "python${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}")
+#endif()
+#
+#
+# Copy required build artifacts to structure which will be used in final package
+#add_custom_command(TARGET ie_api POST_BUILD
+#                   
+#                   COMMAND ${CMAKE_COMMAND} -E make_directory
+#                   ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/inference_engine/
+#
+#                   COMMAND ${CMAKE_COMMAND} -E touch
+#                   ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/__init__.py)
+#
+#if (${WIN32})
+#add_custom_command(TARGET ie_api POST_BUILD
+#                   COMMAND ${CMAKE_COMMAND} -E copy
+#                   ${CMAKE_CURRENT_BINARY_DIR}/Release/ie_api.pyd ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/inference_engine/
+#
+#                   COMMAND ${CMAKE_COMMAND} -E copy
+#                   ${CMAKE_CURRENT_BINARY_DIR}/__init__.py ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/inference_engine/)
+#else()
+#add_custom_command(TARGET ie_api POST_BUILD
+#                   COMMAND ${CMAKE_COMMAND} -E copy
+#                   ${CMAKE_CURRENT_BINARY_DIR}/ie_api.so ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/inference_engine/
+#
+#                   COMMAND ${CMAKE_COMMAND} -E copy
+#                   ${CMAKE_CURRENT_BINARY_DIR}/__init__.py ${CMAKE_SOURCE_DIR}/bin/${python_subdir}/openvino/inference_engine/)
+#endif()

inference-engine/ie_bridges/python/inference_engine/__init__.py

@@ -0,0 +1,3 @@
+from .ie_api import *
+__version__ = get_version()
+__all__ = ['IENetwork', "IEPlugin", "IENetReader"]

inference-engine/ie_bridges/python/inference_engine/ie_api.pxd

@@ -0,0 +1,59 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from .cimport ie_api_impl_defs as C
+from .ie_api_impl_defs cimport Blob, TensorDesc
+
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.memory cimport unique_ptr
+from libcpp cimport bool
+
+cdef class BlobBuffer:
+    cdef Blob.Ptr ptr
+    cdef char*format
+    cdef vector[Py_ssize_t] shape
+    cdef vector[Py_ssize_t] strides
+    cdef reset(self, Blob.Ptr &)
+    cdef char*_get_blob_format(self, const TensorDesc & desc)
+
+    cdef public:
+        total_stride, item_size
+
+cdef class InferRequest:
+    cdef C.InferRequestWrap *impl
+
+    cpdef BlobBuffer _get_input_buffer(self, const string & blob_name)
+    cpdef BlobBuffer _get_output_buffer(self, const string & blob_name)
+
+    cpdef infer(self, inputs = ?)
+    cpdef async_infer(self, inputs = ?)
+    cpdef wait(self, timeout = ?)
+    cpdef get_perf_counts(self)
+    cdef public:
+        _inputs, _outputs
+
+cdef class IENetwork:
+    cdef C.IENetwork impl
+
+
+cdef class ExecutableNetwork:
+    cdef unique_ptr[C.IEExecNetwork] impl
+    cdef public:
+        _requests, async, _request_iterator
+
+cdef class IEPlugin:
+    cdef C.IEPlugin impl
+    cpdef ExecutableNetwork load(self, IENetwork network, int num_requests = ?, config = ?)
+    cpdef void set_config(self, config)
+    cpdef void add_cpu_extension(self, str extension_path) except *
+    cpdef void set_initial_affinity(self, IENetwork network) except *
+    cpdef set get_supported_layers(self, IENetwork net)
+
+cdef class IENetReader:
+    cdef C.IENetReader impl
+
+cdef class IENetLayer:
+    cdef C.IENetLayer impl

inference-engine/ie_bridges/python/inference_engine/ie_api.pyx

@@ -0,0 +1,374 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+#distutils: language=c++
+from cython.operator cimport dereference as deref
+from .cimport ie_api_impl_defs as C
+from .ie_api_impl_defs cimport Blob, TensorDesc, SizeVector, Precision
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.map cimport map
+from libcpp.memory cimport unique_ptr
+from libc.stdint cimport int64_t
+import os
+import numpy as np
+
+cdef extern from "<utility>" namespace "std" nogil:
+    cdef unique_ptr[C.IEExecNetwork] move(unique_ptr[C.IEExecNetwork])
+
+cdef string to_std_string(str py_string):
+    return py_string.encode()
+
+cdef to_py_string(const string & std_string):
+    return bytes(std_string).decode()
+
+cdef dict_to_c_map(py_dict):
+    cdef map[string, string] c_map
+    for k, v in py_dict.items():
+        if type(k) != str or type(v) != str:
+            raise TypeError("Only string keys and values are allowed!")
+        c_map[k.encode()] = v.encode()
+    return c_map
+
+supported_precisions = ["fp32", "fp16", "q78", "i32", "i16", "i8", "u32", "u16"]
+known_plugins = ['CPU', 'GPU', 'FPGA', 'MYRIAD', 'HETERO']
+
+def get_version():
+    return C.get_version().decode()
+
+cdef class IENetLayer:
+    @property
+    def name(self):
+        return self.impl.name.decode()
+    @property
+    def type(self):
+        return self.impl.type.decode()
+    @property
+    def precision(self):
+        return self.impl.precision.decode()
+    @property
+    def affinity(self):
+        return self.impl.affinity.decode()
+    @property
+    def weights(self):
+        cdef map[string, Blob.Ptr] c_weights_map
+        c_weights_map = self.impl.getWeights()
+        weights_map = {}
+        cdef BlobBuffer weights_buffer
+        for weights in c_weights_map:
+            weights_buffer = BlobBuffer()
+            weights_buffer.reset(weights.second)
+            weights_map[weights.first.decode()] = weights_buffer.to_numpy()
+        return weights_map
+    @property
+    def params(self):
+        return {k.decode(): v.decode() for k, v in self.impl.params}
+
+    @affinity.setter
+    def affinity(self, target_affinity):
+        self.impl.setAffinity(target_affinity.encode())
+    @params.setter
+    def params(self, params_map):
+        self.impl.setParams(dict_to_c_map(params_map))
+
+cdef class ExecutableNetwork:
+    def __init__(self):
+        self._requests = []
+
+    def infer(self, inputs=None):
+        current_request = self.requests[0]
+        current_request.infer(inputs)
+        if inputs is not None:
+            return {k: v for k, v in current_request.outputs.items()}
+
+    def start_async(self, request_id, inputs=None):
+        if request_id not in list(range(len(self.requests))):
+            raise ValueError("Incorrect request_id specified!")
+        current_request = self.requests[request_id]
+        current_request.async_infer(inputs)
+        return current_request
+
+    @property
+    def requests(self):
+        return self._requests
+
+cdef class InferRequest:
+    def __init__(self):
+        self._inputs = {}
+        self._outputs = {}
+
+    cpdef BlobBuffer _get_input_buffer(self, const string & blob_name):
+        cdef BlobBuffer buffer = BlobBuffer()
+        buffer.reset(deref(self.impl).getInputBlob(blob_name))
+        return buffer
+
+    cpdef BlobBuffer _get_output_buffer(self, const string & blob_name):
+        cdef BlobBuffer buffer = BlobBuffer()
+        buffer.reset(deref(self.impl).getOutputBlob(blob_name))
+        return buffer
+
+    cpdef infer(self, inputs=None):
+        if inputs is not None:
+            self._fill_inputs(inputs)
+
+        deref(self.impl).infer()
+
+    cpdef async_infer(self, inputs=None):
+        if inputs is not None:
+            self._fill_inputs(inputs)
+
+        deref(self.impl).infer_async()
+
+    cpdef wait(self, timeout=None):
+        if timeout is None:
+            timeout = -1
+        return deref(self.impl).wait(<int64_t> timeout)
+
+    cpdef get_perf_counts(self):
+        cdef map[string, C.ProfileInfo] c_profile = deref(self.impl).getPerformanceCounts()
+        profile = {}
+        for l in c_profile:
+            info = l.second
+            # TODO: add execution index. Check if unsigned int is properly converted to int in python.
+            profile[l.first.decode()] = {"status": info.status.decode(), "exec_type": info.exec_type.decode(),
+                                         "layer_type": info.layer_type.decode(), "real_time": info.real_time,
+                                         "cpu_time": info.cpu_time}
+        return profile
+
+    @property
+    def inputs(self):
+        return self._inputs
+
+    @property
+    def outputs(self):
+        return self._outputs
+
+    def _fill_inputs(self, inputs):
+        for k, v in inputs.items():
+            self.inputs[k][:] = v
+
+cdef class IENetwork:
+    @property
+    def name(self):
+        name = bytes(self.impl.name)
+        return name.decode()
+
+    @property
+    def inputs(self):
+        return {k.decode(): v for k, v in self.impl.inputs}
+
+    @property
+    def outputs(self):
+        return [k.decode() for k in self.impl.outputs]
+
+    @property
+    def batch_size(self):
+        return self.impl.batch_size
+
+    @batch_size.setter
+    def batch_size(self, batch: int):
+        if batch <= 0:
+            raise AttributeError("Invalid batch size {}! Batch size should be positive integer value".format(batch))
+        self.impl.setBatch(batch)
+        self.impl.batch_size = batch
+
+    @property
+    def layers(self):
+        cdef map[string, C.IENetLayer] c_layers = <map[string, C.IENetLayer]>self.impl.getLayers()
+        layers = {}
+        cdef IENetLayer net_l = IENetLayer()
+        for l in c_layers:
+            net_l = IENetLayer()
+            net_l.impl = l.second
+            layers[l.first.decode()] = net_l
+        return layers
+
+    @classmethod
+    def from_ir(cls, model: str, weights: str):
+        if not os.path.isfile(model):
+            raise FileNotFoundError("Path to the model {} doesn't exists or it's a directory".format(model))
+        if not os.path.isfile(weights):
+            raise FileNotFoundError("Path to the weights {} doesn't exists or it's a directory".format(weights))
+        net_reader = IENetReader()
+        return net_reader.read(model, weights)
+
+    # TODO: Use enum with precision type instead of srting parameter when python2 support will not be required.
+    def add_outputs(self, outputs, precision="FP32"):
+        if precision.lower() not in supported_precisions:
+            raise AttributeError("Unsupported precision {}! List of supported precisions: {}".format(precision, supported_precisions))
+        if not isinstance(outputs, list):
+            outputs = [outputs]
+        cdef vector[string] _outputs
+        for l in outputs:
+            _outputs.push_back(l.encode())
+        self.impl.addOutputs(_outputs, precision.lower().encode())
+
+    def reshape(self, input_shapes: dict):
+        cdef map[string, vector[size_t]] c_input_shapes;
+        cdef vector[size_t] c_shape
+        net_inputs = self.inputs
+        for input, shape in input_shapes.items():
+            if input not in net_inputs:
+                raise AttributeError("Specified {} layer not in network inputs {}! ".format(input, net_inputs))
+            for v in shape:
+                c_shape.push_back(v)
+            c_input_shapes[input.encode()] = c_shape
+        self.impl.reshape(c_input_shapes)
+
+cdef class IEPlugin:
+    def __cinit__(self, device: str, plugin_dirs=None):
+        plugin_base = device.split(':')[0]
+        if plugin_base not in known_plugins:
+            raise ValueError("Unknown plugin: {}, expected one of: {}"
+                             .format(plugin_base, ",".join(known_plugins)))
+        if plugin_dirs is None:
+            plugin_dirs = [""]
+        elif isinstance(plugin_dirs, str):
+            plugin_dirs = [plugin_dirs]
+
+        # add package directory to plugin_dirs
+        lib_location = os.path.dirname(os.path.realpath(__file__))
+        plugin_dirs.append(lib_location)
+
+        cpdef string device_ = <string> device.encode()
+        cdef vector[string] dirs_
+        for d in plugin_dirs:
+            dirs_.push_back(<string> d.encode())
+
+        self.impl = C.IEPlugin(device_, dirs_)
+
+    cpdef ExecutableNetwork load(self, IENetwork network, int num_requests=1, config=None):
+        if num_requests <= 0:
+            raise ValueError("Incorrect number of requests specified: {}. Expected positive integer number.".format(num_requests))
+        cdef ExecutableNetwork exec_net = ExecutableNetwork()
+        cdef vector[string] inputs_list
+        cdef vector[string] outputs_list
+        cdef map[string, string] c_config
+
+        if config:
+            for k, v in config.items():
+                c_config[to_std_string(k)] = to_std_string(v)
+
+        exec_net.impl = move(self.impl.load(network.impl, num_requests, c_config))
+
+        requests = []
+        for i in range(deref(exec_net.impl).infer_requests.size()):
+            infer_request = InferRequest()
+            infer_request.impl = &(deref(exec_net.impl).infer_requests[i])
+
+            inputs_list = infer_request.impl.getInputsList()
+            outputs_list = infer_request.impl.getOutputsList()
+
+            for input_b in inputs_list:
+                input_s = input_b.decode()
+                infer_request._inputs[input_s] = infer_request._get_input_buffer(input_b).to_numpy()
+
+            for output_b in outputs_list:
+                output_s = output_b.decode()
+                infer_request._outputs[output_s] = infer_request._get_output_buffer(output_b).to_numpy()
+
+            # create blob buffers
+            requests.append(infer_request)
+        exec_net._requests = tuple(requests)
+
+        return exec_net
+
+    cpdef void set_initial_affinity(self,IENetwork net) except *:
+        if self.device.find("HETERO") == -1:
+            raise RuntimeError("set_initial_affinity method applicable only for HETERO device")
+        self.impl.setInitialAffinity(net.impl)
+
+    cpdef set get_supported_layers(self,IENetwork net):
+        return set([l.decode() for l in  self.impl.queryNetwork(net.impl)])
+
+    @property
+    def device(self):
+        device_name = bytes(self.impl.device_name)
+        return to_py_string(device_name)
+
+    @property
+    def version(self):
+        version = bytes(self.impl.version)
+        return version.decode()
+
+    cpdef void add_cpu_extension(self, extension_path: str) except *:
+        if self.device.find("CPU") == -1:
+            raise RuntimeError("add_cpu_extension method applicable only for CPU or HETERO devices")
+        cdef string extension_str = extension_path.encode()
+        self.impl.addCpuExtension(extension_str)
+
+    cpdef void set_config(self, config):
+        cdef map[string, string] c_config
+        for k, v in config.items():
+            c_config[to_std_string(k)] = to_std_string(v)
+        self.impl.setConfig(c_config)
+
+
+
+cdef class IENetReader:
+    def read(self, model: str, weights: str) -> IENetwork:
+        cdef IENetwork net = IENetwork()
+        net.impl = self.impl.read(model.encode(), weights.encode())
+        return net
+
+cdef class BlobBuffer:
+    """Copy-less accessor for Inference Engine Blob"""
+
+    cdef reset(self, Blob.Ptr & ptr):
+        self.ptr = ptr
+        cdef TensorDesc desc = deref(ptr).getTensorDesc()
+        cdef SizeVector shape = desc.getDims()
+        cdef Py_ssize_t itemsize = deref(ptr).element_size()
+        self.strides.resize(shape.size())
+        self.shape.resize(shape.size())
+
+        total_stride = itemsize
+        # dims are in row major (C - style),
+        # thence strides are computed starting from latest dimension
+        for i in reversed(range(shape.size())):
+            self.strides[i] = total_stride
+            self.shape[i] = shape[i]
+            total_stride *= shape[i]
+
+        self.total_stride = total_stride
+        self.format = self._get_blob_format(desc)
+        self.item_size = itemsize
+
+    def __getbuffer__(self, Py_buffer *buffer, int flags):
+        buffer.buf = C.get_buffer[char](deref(self.ptr))
+        buffer.format = self.format
+        buffer.internal = NULL
+        buffer.itemsize = self.item_size
+        buffer.len = self.total_stride
+        buffer.ndim = self.shape.size()
+        buffer.obj = self
+        buffer.readonly = 0
+        buffer.shape = self.shape.data()
+        buffer.strides = self.strides.data()
+        buffer.suboffsets = NULL
+
+
+    cdef char*_get_blob_format(self, const TensorDesc & desc):
+        cdef Precision precision = desc.getPrecision()
+        name = bytes(precision.name()).decode()
+        # todo: half floats
+        precision_to_format = {
+            'FP32': 'f',  # float
+            'FP16': 'h',  # signed short
+            'Q78': 'h',  # signed short
+            'I16': 'h',  # signed short
+            'U8': 'B',  # unsigned char
+            'I8': 'b',  # signed char
+            'U16': 'H',  # unsigned short
+            'I32': 'i'  # signed int
+        }
+
+        if name not in precision_to_format:
+            raise ValueError("Unknown Blob precision: {}".format(name))
+
+        return precision_to_format[name].encode()
+
+    def to_numpy(self):
+        return np.asarray(self)

inference-engine/ie_bridges/python/inference_engine/ie_api_impl.cpp

@@ -0,0 +1,349 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "ie_api_impl.hpp"
+#include "hetero/hetero_plugin_config.hpp"
+#include "ie_iinfer_request.hpp"
+#define stringify( name ) # name
+#define IE_CHECK_CALL(expr) {                       \
+    auto ret = (expr);                              \
+    if (ret != InferenceEngine::StatusCode::OK) {   \
+        THROW_IE_EXCEPTION << response.msg;         \
+    }                                               \
+}                                                   \
+
+InferenceEnginePython::IENetwork InferenceEnginePython::IENetReader::read(std::string const &model,
+                                                                     std::string const &weights)
+{
+    InferenceEngine::CNNNetReader net_reader;
+    net_reader.ReadNetwork(model);
+    net_reader.ReadWeights(weights);
+
+    const std::string &net_name = net_reader.getName();
+    std::map<std::string, std::vector<size_t>> inputs;
+    const InferenceEngine::InputsDataMap &inputsInfo = net_reader.getNetwork().getInputsInfo();
+    for (auto &item : inputsInfo)
+    {
+        const InferenceEngine::TensorDesc &inputTensorDesc = item.second->getTensorDesc();
+        InferenceEngine::SizeVector dims = inputTensorDesc.getDims();
+        inputs[item.first] = dims;
+    }
+
+    // TODO: store output shapes for each output
+    std::vector<std::string> outputs;
+    const InferenceEngine::OutputsDataMap &outputsInfo = net_reader.getNetwork().getOutputsInfo();
+    for (auto &item : outputsInfo)
+    {
+        outputs.push_back(item.first);
+    }
+    InferenceEngine::CNNNetwork network = net_reader.getNetwork();
+    std::size_t batch_size = network.getBatchSize();
+    return {network, net_name, batch_size, inputs, outputs};
+}
+
+std::map<std::string, InferenceEnginePython::IENetLayer> InferenceEnginePython::IENetwork::getLayers()
+{
+    std::map<std::string, InferenceEnginePython::IENetLayer> result;
+    std::unordered_set<std::string> visisted;
+    const InferenceEngine::InputsDataMap &networkInputs = actual.getInputsInfo();
+
+    using CNNLayerPtrCref = const InferenceEngine::CNNLayerPtr &;
+    std::function<void(CNNLayerPtrCref)> DFS = [&](CNNLayerPtrCref layer) {
+        InferenceEnginePython::IENetLayer layer_info;
+        /* Assumes no cycles in graph */
+        for (auto &od : layer->outData)
+        {
+            for (auto nl : od->getInputTo())
+            {
+                auto i = visisted.find(nl.second->name);
+                if (i != visisted.end())
+                {
+                    continue;
+                }
+                DFS(nl.second);
+            }
+        }
+        visisted.emplace(layer->name);
+        layer_info.layer_ptr = layer;
+        layer_info.name = layer->name;
+        layer_info.type = layer->type;
+        std::string precision = layer->precision.name();
+        layer_info.precision = precision;
+        layer_info.params = layer->params;
+        layer_info.affinity = layer->affinity;
+        result[layer->name] = layer_info;
+    };
+
+    std::set<InferenceEngine::CNNLayerPtr> inputs;
+    for (auto input : networkInputs) {
+        for (auto l : input.second->getInputData()->inputTo) {
+            inputs.insert(l.second);
+        }
+    }
+
+    for (auto &layer : inputs)
+    {
+        DFS(layer);
+    }
+
+    return result;
+
+}
+
+void InferenceEnginePython::IENetwork::addOutputs(const std::vector<std::string> & out_layers, const std::string &precision)
+{
+    std::map <std::string,InferenceEngine::Precision> precision_map = {{"fp32", InferenceEngine::Precision::FP32},
+                                                                       {"fp16", InferenceEngine::Precision::FP16},
+                                                                       {"q78", InferenceEngine::Precision::Q78},
+                                                                       {"i32",  InferenceEngine::Precision::I32},
+                                                                       {"i16",  InferenceEngine::Precision::I16},
+                                                                       {"i8",  InferenceEngine::Precision::I8},
+                                                                       {"u16",  InferenceEngine::Precision::U16},
+                                                                       {"u8",  InferenceEngine::Precision::U8}};
+    for (auto && l : out_layers)
+    {
+        InferenceEngine::OutputsDataMap outputsDataMap = actual.getOutputsInfo();
+        if (outputsDataMap.find(l) != outputsDataMap.end())
+        {
+            continue;
+        }
+        InferenceEngine::CNNLayerPtr cnnLayer = actual.getLayerByName(l.c_str());
+        std::vector<InferenceEngine::DataPtr> outData = cnnLayer->outData;
+        if (outData.size() != 1) {
+            std::cout << "Layer " << l << " has " << outData.size() << " output blobs and can not be set as output." << std::endl;
+            continue;
+        }
+        actual.addOutput(l);
+        InferenceEngine::OutputsDataMap outputsDataMapUpd = actual.getOutputsInfo();
+        outputsDataMapUpd[l]->setPrecision(precision_map[precision]);
+        outputs.push_back(l);
+    }
+}
+
+void InferenceEnginePython::IENetwork::setBatch(const size_t size)
+{
+    actual.setBatchSize(size);
+    const InferenceEngine::InputsDataMap &inputsInfo = actual.getInputsInfo();
+    for (auto &item : inputsInfo)
+    {
+        const InferenceEngine::TensorDesc &inputTensorDesc = item.second->getTensorDesc();
+        InferenceEngine::SizeVector dims = inputTensorDesc.getDims();
+        inputs[item.first] = dims;
+    }
+}
+void InferenceEnginePython::IENetwork::reshape(const std::map<std::string, std::vector<size_t>> & input_shapes){
+    actual.reshape(input_shapes);
+    const InferenceEngine::InputsDataMap &inputsInfo = actual.getInputsInfo();
+    for (auto &item : inputsInfo)
+    {
+        const InferenceEngine::TensorDesc &inputTensorDesc = item.second->getTensorDesc();
+        InferenceEngine::SizeVector dims = inputTensorDesc.getDims();
+        inputs[item.first] = dims;
+    }
+
+}
+InferenceEnginePython::IEPlugin::IEPlugin(const std::string &device, const std::vector<std::string> &plugin_dirs)
+{
+
+    InferenceEngine::PluginDispatcher dispatcher{plugin_dirs};
+    actual = dispatcher.getPluginByDevice(device);
+    const InferenceEngine::Version *pluginVersion;
+    actual->GetVersion(pluginVersion);
+    version = std::to_string(pluginVersion->apiVersion.major) + ".";
+    version += std::to_string(pluginVersion->apiVersion.minor) + ".";
+    version += pluginVersion->buildNumber;
+    device_name = device;
+}
+
+void InferenceEnginePython::IEPlugin::setInitialAffinity(InferenceEnginePython::IENetwork &net)
+{
+    InferenceEngine::HeteroPluginPtr hetero_plugin(actual);
+    InferenceEngine::ResponseDesc response;
+    auto &network = net.actual;
+    IE_CHECK_CALL(hetero_plugin->SetAffinity(network, {}, &response));
+}
+std::set<std::string> InferenceEnginePython::IEPlugin::queryNetwork(InferenceEnginePython::IENetwork &net)
+{
+    InferenceEngine::CNNNetwork &network = net.actual;
+    InferenceEngine::QueryNetworkResult queryRes;
+    actual->QueryNetwork(network, queryRes);
+    return queryRes.supportedLayers;
+}
+
+
+void InferenceEnginePython::IENetLayer::setAffinity(const std::string & target_affinity){
+    layer_ptr->affinity = target_affinity;
+}
+
+void InferenceEnginePython::IENetLayer::setParams(const std::map<std::string, std::string> & params_map){
+    layer_ptr->params = params_map;
+}
+
+std::map<std::string, InferenceEngine::Blob::Ptr> InferenceEnginePython::IENetLayer::getWeights(){
+    auto w_layer = std::dynamic_pointer_cast<InferenceEngine::WeightableLayer>(layer_ptr);
+    // IF current layer is weightable gather weights and biases from casted WeightableLayer and all other blobs
+    // considered as custom and gathered from blobs field pf CNNLayer.
+    std::map<std::string, InferenceEngine::Blob::Ptr> weights;
+    if (w_layer != nullptr){
+        if (w_layer->_weights != nullptr){
+            weights["weights"] = w_layer->_weights;
+        }
+        if (w_layer->_biases != nullptr){
+            weights["biases"] = w_layer->_biases;
+        }
+        for (auto it : w_layer->blobs){
+            if (it.first == "weights" || it.first == "biases"){
+                continue;
+            }
+            weights[it.first] = it.second;
+        }
+    }
+    // Otherwise all layer's blobs are considered as custom and gathered from CNNLayer
+    else {
+        std::map<std::string, InferenceEngine::Blob::Ptr> map_placeholder;
+        weights = map_placeholder; // If layer has no blobs it should not be missed from weights map
+        for (auto it : layer_ptr->blobs){
+            weights[it.first] = it.second;
+        }
+    }
+    return weights;
+}
+
+void InferenceEnginePython::IEPlugin::addCpuExtension(const std::string &extension_path)
+{
+    InferenceEngine::ResponseDesc response;
+    auto extension_ptr = InferenceEngine::make_so_pointer<InferenceEngine::IExtension>(extension_path);
+    auto extension = std::dynamic_pointer_cast<InferenceEngine::IExtension>(extension_ptr);
+    IE_CHECK_CALL(actual->AddExtension(extension, &response))
+}
+
+std::unique_ptr<InferenceEnginePython::IEExecNetwork>
+InferenceEnginePython::IEPlugin::load(InferenceEnginePython::IENetwork &net,
+                                      int num_requests,
+                                      const std::map<std::string, std::string> &config)
+{
+    InferenceEngine::ResponseDesc response;
+    auto exec_network = InferenceEnginePython::make_unique<InferenceEnginePython::IEExecNetwork>(net.name, num_requests);
+
+    IE_CHECK_CALL(actual->LoadNetwork(exec_network->actual, net.actual, config, &response))
+    const InferenceEngine::InputsDataMap &inputs_info = net.actual.getInputsInfo();
+    const InferenceEngine::OutputsDataMap &outputs_info = net.actual.getOutputsInfo();
+
+
+    for (size_t i = 0; i < num_requests; ++i) {
+        InferRequestWrap &infer_request = exec_network->infer_requests[i];
+        IE_CHECK_CALL(exec_network->actual->CreateInferRequest(infer_request.request_ptr, &response))
+
+        for (const auto& input : inputs_info) {
+            infer_request.inputs[input.first] = nullptr;
+            infer_request.request_ptr->GetBlob(input.first.c_str(), infer_request.inputs[input.first], &response);
+        }
+        for (const auto& output : outputs_info) {
+            infer_request.request_ptr->GetBlob(output.first.c_str(), infer_request.outputs[output.first], &response);
+        }
+    }
+
+    return exec_network;
+}
+
+void InferenceEnginePython::IEPlugin::setConfig(const std::map<std::string, std::string> & config) {
+    InferenceEngine::ResponseDesc response;
+    IE_CHECK_CALL(actual->SetConfig(config, &response))
+}
+
+InferenceEnginePython::IEExecNetwork::IEExecNetwork(const std::string &name, size_t num_requests) :
+    infer_requests(num_requests), name(name)
+{
+}
+
+void InferenceEnginePython::IEExecNetwork::infer()
+{
+    InferenceEngine::ResponseDesc response;
+    InferRequestWrap &request = infer_requests[0];
+    request.request_ptr->Infer(&response);
+}
+
+
+InferenceEngine::Blob::Ptr &InferenceEnginePython::InferRequestWrap::getInputBlob(const std::string &blob_name)
+{
+    return inputs.at(blob_name);
+}
+
+InferenceEngine::Blob::Ptr &InferenceEnginePython::InferRequestWrap::getOutputBlob(const std::string &blob_name)
+{
+    return outputs.at(blob_name);
+}
+
+std::vector<std::string> InferenceEnginePython::InferRequestWrap::getInputsList() {
+    std::vector<std::string> inputs_list;
+    inputs_list.reserve(inputs.size());
+    std::transform(inputs.begin(), inputs.end(), std::back_inserter(inputs_list), [] (InferenceEngine::BlobMap::value_type it) -> std::string {
+        return it.first;
+    });
+    return inputs_list;
+}
+
+std::vector<std::string> InferenceEnginePython::InferRequestWrap::getOutputsList() {
+    std::vector<std::string> outputs_list;
+    outputs_list.reserve(inputs.size());
+    std::transform(outputs.begin(), outputs.end(), std::back_inserter(outputs_list), [] (InferenceEngine::BlobMap::value_type it) -> std::string {
+        return it.first;
+    });
+    return outputs_list;
+}
+
+void InferenceEnginePython::InferRequestWrap::infer() {
+    InferenceEngine::ResponseDesc responseDesc;
+    request_ptr->Infer(&responseDesc);
+}
+
+void InferenceEnginePython::InferRequestWrap::infer_async() {
+    InferenceEngine::ResponseDesc responseDesc;
+    request_ptr->StartAsync(&responseDesc);
+}
+
+int InferenceEnginePython::InferRequestWrap::wait(int64_t timeout) {
+    InferenceEngine::ResponseDesc responseDesc;
+    InferenceEngine::StatusCode code = request_ptr->Wait(timeout, &responseDesc);
+    return static_cast<int >(code);
+}
+
+std::map<std::string, InferenceEnginePython::ProfileInfo> InferenceEnginePython::InferRequestWrap::getPerformanceCounts(){
+    std::map<std::string, InferenceEngine::InferenceEngineProfileInfo> perf_counts;
+    InferenceEngine::ResponseDesc response;
+    request_ptr->GetPerformanceCounts(perf_counts, &response);
+    std::map<std::string, InferenceEnginePython::ProfileInfo> perf_map;
+
+    for (auto it : perf_counts){
+        InferenceEnginePython::ProfileInfo profile_info;
+        switch (it.second.status) {
+            case InferenceEngine::InferenceEngineProfileInfo::EXECUTED:
+                profile_info.status = "EXECUTED";
+                break;
+            case InferenceEngine::InferenceEngineProfileInfo::NOT_RUN:
+                profile_info.status = "NOT_RUN";
+                break;
+            case InferenceEngine::InferenceEngineProfileInfo::OPTIMIZED_OUT:
+                profile_info.status = "OPTIMIZED_OUT";
+                break;
+            default:
+                profile_info.status = "UNKNOWN";
+        }
+        profile_info.exec_type = it.second.exec_type;
+        profile_info.layer_type = it.second.layer_type;
+        profile_info.cpu_time = it.second.cpu_uSec;
+        profile_info.real_time = it.second.realTime_uSec;
+        perf_map[it.first] = profile_info;
+    }
+    return perf_map;
+}
+
+std::string InferenceEnginePython::get_version() {
+    auto version = InferenceEngine::GetInferenceEngineVersion();
+    std::string version_str = std::to_string(version->apiVersion.major) + ".";
+    version_str += std::to_string(version->apiVersion.minor) + ".";
+    version_str += version->buildNumber;
+    return version_str;
+}

inference-engine/ie_bridges/python/inference_engine/ie_api_impl.hpp

@@ -0,0 +1,124 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#ifndef INFERENCE_ENGINE_DRIVER_IE_API_IMPL_HPP
+#define INFERENCE_ENGINE_DRIVER_IE_API_IMPL_HPP
+
+#include <string>
+#include <inference_engine.hpp>
+#include <iterator>
+#include <iostream>
+#include <algorithm>
+#include <sstream>
+#include "ie_extension.h"
+
+namespace InferenceEnginePython {
+//struct BlobInfo {
+//    int layout;
+//    std::vector<std::size_t> dims;
+//    std::string name;
+//    std::vector<std::string> inputTo;
+//};
+struct IENetLayer {
+    InferenceEngine::CNNLayerPtr layer_ptr;
+    std::string name;
+    std::string type;
+    std::string precision;
+    std::string affinity;
+    std::map<std::string, std::string> params;
+//    std::map<std::string, InferenceEnginePython::BlobInfo> blob_info;
+//    std::map<std::string, InferenceEngine::Blob::Ptr> weights;
+    void setAffinity(const std::string & target_affinity);
+    void setParams(const std::map<std::string, std::string> & params_map);
+    std::map<std::string, InferenceEngine::Blob::Ptr> getWeights();
+};
+struct ProfileInfo {
+    std::string status;
+    std::string exec_type;
+    std::string layer_type;
+    long long real_time;
+    long long cpu_time;
+    unsigned execution_index;
+};
+struct IENetwork {
+    InferenceEngine::CNNNetwork actual;
+    std::string name;
+    std::size_t batch_size;
+    std::map<std::string, std::vector<size_t>> inputs;
+    std::vector<std::string> outputs;
+    void setPrecision() {
+        InferenceEngine::CNNNetwork one;
+        InferenceEngine::CNNNetwork second(std::move(one));
+    }
+    void setBatch(const size_t size);
+    void addOutputs(const std::vector<std::string> &out_layers, const std::string &precision);
+    std::map<std::string, InferenceEnginePython::IENetLayer> getLayers();
+    void reshape(const std::map<std::string, std::vector<size_t>> & input_shapes);
+};
+
+struct IENetReader {
+    static IENetwork read(std::string const &model, std::string const &weights);
+    std::vector<std::pair<std::string, std::string>> getLayers();
+};
+
+struct InferRequestWrap {
+    InferenceEngine::IInferRequest::Ptr request_ptr;
+    InferenceEngine::BlobMap inputs;
+    InferenceEngine::BlobMap outputs;
+
+    void infer();
+    void infer_async();
+    int  wait(int64_t timeout);
+    InferenceEngine::Blob::Ptr &getInputBlob(const std::string &blob_name);
+    InferenceEngine::Blob::Ptr &getOutputBlob(const std::string &blob_name);
+    std::vector<std::string> getInputsList();
+    std::vector<std::string> getOutputsList();
+    std::map<std::string, InferenceEnginePython::ProfileInfo> getPerformanceCounts();
+};
+
+
+struct IEExecNetwork {
+    InferenceEngine::IExecutableNetwork::Ptr actual;
+    std::vector<InferRequestWrap> infer_requests;
+    IEExecNetwork(const std::string &name, size_t num_requests);
+
+    std::string name;
+    int next_req_index = 0;
+    bool async;
+    void infer();
+};
+
+
+struct IEPlugin {
+    std::unique_ptr<InferenceEnginePython::IEExecNetwork> load(InferenceEnginePython::IENetwork &net,
+                                                                   int num_requests,
+                                                                   const std::map<std::string,std::string> &config);
+    std::string device_name;
+    std::string version;
+    void setConfig(const std::map<std::string, std::string> &);
+    void addCpuExtension(const std::string &extension_path);
+    void setInitialAffinity(InferenceEnginePython::IENetwork &net);
+    IEPlugin(const std::string &device, const std::vector<std::string> &plugin_dirs);
+    IEPlugin() = default;
+    std::set<std::string> queryNetwork(InferenceEnginePython::IENetwork &net);
+    InferenceEngine::InferenceEnginePluginPtr actual;
+
+};
+
+template<class T>
+T* get_buffer(InferenceEngine::Blob& blob) {
+    return blob.buffer().as<T *>();
+}
+
+template<class T, class... Args>
+std::unique_ptr<T> make_unique(Args&&... args)
+{
+    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+std::string get_version();
+}; // InferenceEnginePython
+
+#endif //INFERENCE_ENGINE_DRIVER_IE_API_IMPL_HPP

inference-engine/ie_bridges/python/inference_engine/ie_api_impl_defs.pxd

@@ -0,0 +1,108 @@
+# Copyright (C) 2018 Intel Corporation
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+from libc.stddef cimport size_t
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.map cimport map
+from libcpp.set cimport set
+from libcpp.pair cimport pair
+from libcpp.memory cimport unique_ptr, shared_ptr
+from libcpp cimport bool
+from libc.stdint cimport int64_t
+
+
+
+cdef extern from "<inference_engine.hpp>" namespace "InferenceEngine":
+    ctypedef vector[size_t] SizeVector
+
+    cdef cppclass TensorDesc:
+        SizeVector& getDims()
+        const Precision& getPrecision() const
+
+    cdef cppclass Blob:
+        ctypedef shared_ptr[Blob] Ptr
+        const TensorDesc& getTensorDesc() const
+        size_t element_size()  const
+
+    cdef cppclass Precision:
+        const char* name() const
+
+
+cdef extern from "ie_api_impl.hpp" namespace "InferenceEnginePython":
+    cdef cppclass IENetLayer:
+        string name
+        string type
+        string precision
+        string affinity
+        map[string, string] params
+        # map[string, BlobInfo] blob_info
+        # map[string, Blob.Ptr] weights;
+        void setAffinity(const string & target_affinity) except +
+        void setParams(const map[string, string] & params_map) except +
+        map[string, Blob.Ptr] getWeights() except +
+
+    # cdef cppclass BlobInfo:
+    #    int layout
+    #    vector[size_t] dims
+    #    string name
+    #    vector[string] inputTo
+
+    cdef cppclass ProfileInfo:
+        string status
+        string exec_type
+        string layer_type
+        long long real_time
+        long long cpu_time
+        unsigned int execution_index
+
+    cdef cppclass WeightsInfo:
+        Blob.Ptr &weights;
+        Blob.Ptr &biases;
+        map[string, Blob.Ptr] custom_blobs;
+
+
+    cdef cppclass IEExecNetwork:
+        vector[InferRequestWrap] infer_requests
+
+    cdef cppclass IENetwork:
+        string name
+        size_t batch_size
+        map[string, vector[size_t]] inputs
+        vector[string] outputs
+        map[string, IENetLayer] getLayers() except +
+        void addOutputs(vector[string] &, string &) except +
+        void setAffinity(map[string, string] &types_affinity_map, map[string, string] &layers_affinity_map) except +
+        void setBatch(size_t size) except +
+        void setLayerParams(map[string, map[string, string]] params_map) except +
+        void reshape(map[string, vector[size_t]] input_shapes) except +
+
+    cdef cppclass IEPlugin:
+        IEPlugin() except +
+        IEPlugin(const string &, const vector[string] &) except +
+        unique_ptr[IEExecNetwork] load(IENetwork & net, int num_requests, const map[string, string]& config) except +
+        void addCpuExtension(const string &) except +
+        void setConfig(const map[string, string]&) except +
+        void setInitialAffinity(IENetwork & net) except +
+        set[string] queryNetwork(const IENetwork &net) except +
+        string device_name
+        string version
+
+    cdef cppclass IENetReader:
+        IENetwork read(const string &, const string &) except +
+
+    cdef cppclass InferRequestWrap:
+        vector[string] getInputsList() except +
+        vector[string] getOutputsList() except +
+        Blob.Ptr& getOutputBlob(const string &blob_name) except +
+        Blob.Ptr& getInputBlob(const string &blob_name) except +
+        map[string, ProfileInfo] getPerformanceCounts() except +
+        void infer() except +
+        void infer_async() except +
+        int wait(int64_t timeout) except +
+
+    cdef T* get_buffer[T](Blob &)
+
+    cdef string get_version()

inference-engine/ie_bridges/python/requirements.txt

@@ -0,0 +1,3 @@
+opencv-python
+numpy
+cython

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/image_net_synset.txt

@@ -0,0 +1,1000 @@
+n01440764 tench, Tinca tinca
+n01443537 goldfish, Carassius auratus
+n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+n01491361 tiger shark, Galeocerdo cuvieri
+n01494475 hammerhead, hammerhead shark
+n01496331 electric ray, crampfish, numbfish, torpedo
+n01498041 stingray
+n01514668 cock
+n01514859 hen
+n01518878 ostrich, Struthio camelus
+n01530575 brambling, Fringilla montifringilla
+n01531178 goldfinch, Carduelis carduelis
+n01532829 house finch, linnet, Carpodacus mexicanus
+n01534433 junco, snowbird
+n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea
+n01558993 robin, American robin, Turdus migratorius
+n01560419 bulbul
+n01580077 jay
+n01582220 magpie
+n01592084 chickadee
+n01601694 water ouzel, dipper
+n01608432 kite
+n01614925 bald eagle, American eagle, Haliaeetus leucocephalus
+n01616318 vulture
+n01622779 great grey owl, great gray owl, Strix nebulosa
+n01629819 European fire salamander, Salamandra salamandra
+n01630670 common newt, Triturus vulgaris
+n01631663 eft
+n01632458 spotted salamander, Ambystoma maculatum
+n01632777 axolotl, mud puppy, Ambystoma mexicanum
+n01641577 bullfrog, Rana catesbeiana
+n01644373 tree frog, tree-frog
+n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+n01664065 loggerhead, loggerhead turtle, Caretta caretta
+n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+n01667114 mud turtle
+n01667778 terrapin
+n01669191 box turtle, box tortoise
+n01675722 banded gecko
+n01677366 common iguana, iguana, Iguana iguana
+n01682714 American chameleon, anole, Anolis carolinensis
+n01685808 whiptail, whiptail lizard
+n01687978 agama
+n01688243 frilled lizard, Chlamydosaurus kingi
+n01689811 alligator lizard
+n01692333 Gila monster, Heloderma suspectum
+n01693334 green lizard, Lacerta viridis
+n01694178 African chameleon, Chamaeleo chamaeleon
+n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+n01697457 African crocodile, Nile crocodile, Crocodylus niloticus
+n01698640 American alligator, Alligator mississipiensis
+n01704323 triceratops
+n01728572 thunder snake, worm snake, Carphophis amoenus
+n01728920 ringneck snake, ring-necked snake, ring snake
+n01729322 hognose snake, puff adder, sand viper
+n01729977 green snake, grass snake
+n01734418 king snake, kingsnake
+n01735189 garter snake, grass snake
+n01737021 water snake
+n01739381 vine snake
+n01740131 night snake, Hypsiglena torquata
+n01742172 boa constrictor, Constrictor constrictor
+n01744401 rock python, rock snake, Python sebae
+n01748264 Indian cobra, Naja naja
+n01749939 green mamba
+n01751748 sea snake
+n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus
+n01756291 sidewinder, horned rattlesnake, Crotalus cerastes
+n01768244 trilobite
+n01770081 harvestman, daddy longlegs, Phalangium opilio
+n01770393 scorpion
+n01773157 black and gold garden spider, Argiope aurantia
+n01773549 barn spider, Araneus cavaticus
+n01773797 garden spider, Aranea diademata
+n01774384 black widow, Latrodectus mactans
+n01774750 tarantula
+n01775062 wolf spider, hunting spider
+n01776313 tick
+n01784675 centipede
+n01795545 black grouse
+n01796340 ptarmigan
+n01797886 ruffed grouse, partridge, Bonasa umbellus
+n01798484 prairie chicken, prairie grouse, prairie fowl
+n01806143 peacock
+n01806567 quail
+n01807496 partridge
+n01817953 African grey, African gray, Psittacus erithacus
+n01818515 macaw
+n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+n01820546 lorikeet
+n01824575 coucal
+n01828970 bee eater
+n01829413 hornbill
+n01833805 hummingbird
+n01843065 jacamar
+n01843383 toucan
+n01847000 drake
+n01855032 red-breasted merganser, Mergus serrator
+n01855672 goose
+n01860187 black swan, Cygnus atratus
+n01871265 tusker
+n01872401 echidna, spiny anteater, anteater
+n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+n01877812 wallaby, brush kangaroo
+n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+n01883070 wombat
+n01910747 jellyfish
+n01914609 sea anemone, anemone
+n01917289 brain coral
+n01924916 flatworm, platyhelminth
+n01930112 nematode, nematode worm, roundworm
+n01943899 conch
+n01944390 snail
+n01945685 slug
+n01950731 sea slug, nudibranch
+n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore
+n01968897 chambered nautilus, pearly nautilus, nautilus
+n01978287 Dungeness crab, Cancer magister
+n01978455 rock crab, Cancer irroratus
+n01980166 fiddler crab
+n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus
+n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+n01985128 crayfish, crawfish, crawdad, crawdaddy
+n01986214 hermit crab
+n01990800 isopod
+n02002556 white stork, Ciconia ciconia
+n02002724 black stork, Ciconia nigra
+n02006656 spoonbill
+n02007558 flamingo
+n02009229 little blue heron, Egretta caerulea
+n02009912 American egret, great white heron, Egretta albus
+n02011460 bittern
+n02012849 crane
+n02013706 limpkin, Aramus pictus
+n02017213 European gallinule, Porphyrio porphyrio
+n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana
+n02018795 bustard
+n02025239 ruddy turnstone, Arenaria interpres
+n02027492 red-backed sandpiper, dunlin, Erolia alpina
+n02028035 redshank, Tringa totanus
+n02033041 dowitcher
+n02037110 oystercatcher, oyster catcher
+n02051845 pelican
+n02056570 king penguin, Aptenodytes patagonica
+n02058221 albatross, mollymawk
+n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+n02074367 dugong, Dugong dugon
+n02077923 sea lion
+n02085620 Chihuahua
+n02085782 Japanese spaniel
+n02085936 Maltese dog, Maltese terrier, Maltese
+n02086079 Pekinese, Pekingese, Peke
+n02086240 Shih-Tzu
+n02086646 Blenheim spaniel
+n02086910 papillon
+n02087046 toy terrier
+n02087394 Rhodesian ridgeback
+n02088094 Afghan hound, Afghan
+n02088238 basset, basset hound
+n02088364 beagle
+n02088466 bloodhound, sleuthhound
+n02088632 bluetick
+n02089078 black-and-tan coonhound
+n02089867 Walker hound, Walker foxhound
+n02089973 English foxhound
+n02090379 redbone
+n02090622 borzoi, Russian wolfhound
+n02090721 Irish wolfhound
+n02091032 Italian greyhound
+n02091134 whippet
+n02091244 Ibizan hound, Ibizan Podenco
+n02091467 Norwegian elkhound, elkhound
+n02091635 otterhound, otter hound
+n02091831 Saluki, gazelle hound
+n02092002 Scottish deerhound, deerhound
+n02092339 Weimaraner
+n02093256 Staffordshire bullterrier, Staffordshire bull terrier
+n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+n02093647 Bedlington terrier
+n02093754 Border terrier
+n02093859 Kerry blue terrier
+n02093991 Irish terrier
+n02094114 Norfolk terrier
+n02094258 Norwich terrier
+n02094433 Yorkshire terrier
+n02095314 wire-haired fox terrier
+n02095570 Lakeland terrier
+n02095889 Sealyham terrier, Sealyham
+n02096051 Airedale, Airedale terrier
+n02096177 cairn, cairn terrier
+n02096294 Australian terrier
+n02096437 Dandie Dinmont, Dandie Dinmont terrier
+n02096585 Boston bull, Boston terrier
+n02097047 miniature schnauzer
+n02097130 giant schnauzer
+n02097209 standard schnauzer
+n02097298 Scotch terrier, Scottish terrier, Scottie
+n02097474 Tibetan terrier, chrysanthemum dog
+n02097658 silky terrier, Sydney silky
+n02098105 soft-coated wheaten terrier
+n02098286 West Highland white terrier
+n02098413 Lhasa, Lhasa apso
+n02099267 flat-coated retriever
+n02099429 curly-coated retriever
+n02099601 golden retriever
+n02099712 Labrador retriever
+n02099849 Chesapeake Bay retriever
+n02100236 German short-haired pointer
+n02100583 vizsla, Hungarian pointer
+n02100735 English setter
+n02100877 Irish setter, red setter
+n02101006 Gordon setter
+n02101388 Brittany spaniel
+n02101556 clumber, clumber spaniel
+n02102040 English springer, English springer spaniel
+n02102177 Welsh springer spaniel
+n02102318 cocker spaniel, English cocker spaniel, cocker
+n02102480 Sussex spaniel
+n02102973 Irish water spaniel
+n02104029 kuvasz
+n02104365 schipperke
+n02105056 groenendael
+n02105162 malinois
+n02105251 briard
+n02105412 kelpie
+n02105505 komondor
+n02105641 Old English sheepdog, bobtail
+n02105855 Shetland sheepdog, Shetland sheep dog, Shetland
+n02106030 collie
+n02106166 Border collie
+n02106382 Bouvier des Flandres, Bouviers des Flandres
+n02106550 Rottweiler
+n02106662 German shepherd, German shepherd dog, German police dog, alsatian
+n02107142 Doberman, Doberman pinscher
+n02107312 miniature pinscher
+n02107574 Greater Swiss Mountain dog
+n02107683 Bernese mountain dog
+n02107908 Appenzeller
+n02108000 EntleBucher
+n02108089 boxer
+n02108422 bull mastiff
+n02108551 Tibetan mastiff
+n02108915 French bulldog
+n02109047 Great Dane
+n02109525 Saint Bernard, St Bernard
+n02109961 Eskimo dog, husky
+n02110063 malamute, malemute, Alaskan malamute
+n02110185 Siberian husky
+n02110341 dalmatian, coach dog, carriage dog
+n02110627 affenpinscher, monkey pinscher, monkey dog
+n02110806 basenji
+n02110958 pug, pug-dog
+n02111129 Leonberg
+n02111277 Newfoundland, Newfoundland dog
+n02111500 Great Pyrenees
+n02111889 Samoyed, Samoyede
+n02112018 Pomeranian
+n02112137 chow, chow chow
+n02112350 keeshond
+n02112706 Brabancon griffon
+n02113023 Pembroke, Pembroke Welsh corgi
+n02113186 Cardigan, Cardigan Welsh corgi
+n02113624 toy poodle
+n02113712 miniature poodle
+n02113799 standard poodle
+n02113978 Mexican hairless
+n02114367 timber wolf, grey wolf, gray wolf, Canis lupus
+n02114548 white wolf, Arctic wolf, Canis lupus tundrarum
+n02114712 red wolf, maned wolf, Canis rufus, Canis niger
+n02114855 coyote, prairie wolf, brush wolf, Canis latrans
+n02115641 dingo, warrigal, warragal, Canis dingo
+n02115913 dhole, Cuon alpinus
+n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+n02117135 hyena, hyaena
+n02119022 red fox, Vulpes vulpes
+n02119789 kit fox, Vulpes macrotis
+n02120079 Arctic fox, white fox, Alopex lagopus
+n02120505 grey fox, gray fox, Urocyon cinereoargenteus
+n02123045 tabby, tabby cat
+n02123159 tiger cat
+n02123394 Persian cat
+n02123597 Siamese cat, Siamese
+n02124075 Egyptian cat
+n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+n02127052 lynx, catamount
+n02128385 leopard, Panthera pardus
+n02128757 snow leopard, ounce, Panthera uncia
+n02128925 jaguar, panther, Panthera onca, Felis onca
+n02129165 lion, king of beasts, Panthera leo
+n02129604 tiger, Panthera tigris
+n02130308 cheetah, chetah, Acinonyx jubatus
+n02132136 brown bear, bruin, Ursus arctos
+n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus
+n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+n02134418 sloth bear, Melursus ursinus, Ursus ursinus
+n02137549 mongoose
+n02138441 meerkat, mierkat
+n02165105 tiger beetle
+n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+n02167151 ground beetle, carabid beetle
+n02168699 long-horned beetle, longicorn, longicorn beetle
+n02169497 leaf beetle, chrysomelid
+n02172182 dung beetle
+n02174001 rhinoceros beetle
+n02177972 weevil
+n02190166 fly
+n02206856 bee
+n02219486 ant, emmet, pismire
+n02226429 grasshopper, hopper
+n02229544 cricket
+n02231487 walking stick, walkingstick, stick insect
+n02233338 cockroach, roach
+n02236044 mantis, mantid
+n02256656 cicada, cicala
+n02259212 leafhopper
+n02264363 lacewing, lacewing fly
+n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+n02268853 damselfly
+n02276258 admiral
+n02277742 ringlet, ringlet butterfly
+n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+n02280649 cabbage butterfly
+n02281406 sulphur butterfly, sulfur butterfly
+n02281787 lycaenid, lycaenid butterfly
+n02317335 starfish, sea star
+n02319095 sea urchin
+n02321529 sea cucumber, holothurian
+n02325366 wood rabbit, cottontail, cottontail rabbit
+n02326432 hare
+n02328150 Angora, Angora rabbit
+n02342885 hamster
+n02346627 porcupine, hedgehog
+n02356798 fox squirrel, eastern fox squirrel, Sciurus niger
+n02361337 marmot
+n02363005 beaver
+n02364673 guinea pig, Cavia cobaya
+n02389026 sorrel
+n02391049 zebra
+n02395406 hog, pig, grunter, squealer, Sus scrofa
+n02396427 wild boar, boar, Sus scrofa
+n02397096 warthog
+n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius
+n02403003 ox
+n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+n02410509 bison
+n02412080 ram, tup
+n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+n02417914 ibex, Capra ibex
+n02422106 hartebeest
+n02422699 impala, Aepyceros melampus
+n02423022 gazelle
+n02437312 Arabian camel, dromedary, Camelus dromedarius
+n02437616 llama
+n02441942 weasel
+n02442845 mink
+n02443114 polecat, fitch, foulmart, foumart, Mustela putorius
+n02443484 black-footed ferret, ferret, Mustela nigripes
+n02444819 otter
+n02445715 skunk, polecat, wood pussy
+n02447366 badger
+n02454379 armadillo
+n02457408 three-toed sloth, ai, Bradypus tridactylus
+n02480495 orangutan, orang, orangutang, Pongo pygmaeus
+n02480855 gorilla, Gorilla gorilla
+n02481823 chimpanzee, chimp, Pan troglodytes
+n02483362 gibbon, Hylobates lar
+n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus
+n02484975 guenon, guenon monkey
+n02486261 patas, hussar monkey, Erythrocebus patas
+n02486410 baboon
+n02487347 macaque
+n02488291 langur
+n02488702 colobus, colobus monkey
+n02489166 proboscis monkey, Nasalis larvatus
+n02490219 marmoset
+n02492035 capuchin, ringtail, Cebus capucinus
+n02492660 howler monkey, howler
+n02493509 titi, titi monkey
+n02493793 spider monkey, Ateles geoffroyi
+n02494079 squirrel monkey, Saimiri sciureus
+n02497673 Madagascar cat, ring-tailed lemur, Lemur catta
+n02500267 indri, indris, Indri indri, Indri brevicaudatus
+n02504013 Indian elephant, Elephas maximus
+n02504458 African elephant, Loxodonta africana
+n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+n02514041 barracouta, snoek
+n02526121 eel
+n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+n02606052 rock beauty, Holocanthus tricolor
+n02607072 anemone fish
+n02640242 sturgeon
+n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus
+n02643566 lionfish
+n02655020 puffer, pufferfish, blowfish, globefish
+n02666196 abacus
+n02667093 abaya
+n02669723 academic gown, academic robe, judge's robe
+n02672831 accordion, piano accordion, squeeze box
+n02676566 acoustic guitar
+n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier
+n02690373 airliner
+n02692877 airship, dirigible
+n02699494 altar
+n02701002 ambulance
+n02704792 amphibian, amphibious vehicle
+n02708093 analog clock
+n02727426 apiary, bee house
+n02730930 apron
+n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+n02749479 assault rifle, assault gun
+n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack
+n02776631 bakery, bakeshop, bakehouse
+n02777292 balance beam, beam
+n02782093 balloon
+n02783161 ballpoint, ballpoint pen, ballpen, Biro
+n02786058 Band Aid
+n02787622 banjo
+n02788148 bannister, banister, balustrade, balusters, handrail
+n02790996 barbell
+n02791124 barber chair
+n02791270 barbershop
+n02793495 barn
+n02794156 barometer
+n02795169 barrel, cask
+n02797295 barrow, garden cart, lawn cart, wheelbarrow
+n02799071 baseball
+n02802426 basketball
+n02804414 bassinet
+n02804610 bassoon
+n02807133 bathing cap, swimming cap
+n02808304 bath towel
+n02808440 bathtub, bathing tub, bath, tub
+n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+n02814860 beacon, lighthouse, beacon light, pharos
+n02815834 beaker
+n02817516 bearskin, busby, shako
+n02823428 beer bottle
+n02823750 beer glass
+n02825657 bell cote, bell cot
+n02834397 bib
+n02835271 bicycle-built-for-two, tandem bicycle, tandem
+n02837789 bikini, two-piece
+n02840245 binder, ring-binder
+n02841315 binoculars, field glasses, opera glasses
+n02843684 birdhouse
+n02859443 boathouse
+n02860847 bobsled, bobsleigh, bob
+n02865351 bolo tie, bolo, bola tie, bola
+n02869837 bonnet, poke bonnet
+n02870880 bookcase
+n02871525 bookshop, bookstore, bookstall
+n02877765 bottlecap
+n02879718 bow
+n02883205 bow tie, bow-tie, bowtie
+n02892201 brass, memorial tablet, plaque
+n02892767 brassiere, bra, bandeau
+n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty
+n02895154 breastplate, aegis, egis
+n02906734 broom
+n02909870 bucket, pail
+n02910353 buckle
+n02916936 bulletproof vest
+n02917067 bullet train, bullet
+n02927161 butcher shop, meat market
+n02930766 cab, hack, taxi, taxicab
+n02939185 caldron, cauldron
+n02948072 candle, taper, wax light
+n02950826 cannon
+n02951358 canoe
+n02951585 can opener, tin opener
+n02963159 cardigan
+n02965783 car mirror
+n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig
+n02966687 carpenter's kit, tool kit
+n02971356 carton
+n02974003 car wheel
+n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+n02978881 cassette
+n02979186 cassette player
+n02980441 castle
+n02981792 catamaran
+n02988304 CD player
+n02992211 cello, violoncello
+n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone
+n02999410 chain
+n03000134 chainlink fence
+n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+n03000684 chain saw, chainsaw
+n03014705 chest
+n03016953 chiffonier, commode
+n03017168 chime, bell, gong
+n03018349 china cabinet, china closet
+n03026506 Christmas stocking
+n03028079 church, church building
+n03032252 cinema, movie theater, movie theatre, movie house, picture palace
+n03041632 cleaver, meat cleaver, chopper
+n03042490 cliff dwelling
+n03045698 cloak
+n03047690 clog, geta, patten, sabot
+n03062245 cocktail shaker
+n03063599 coffee mug
+n03063689 coffeepot
+n03065424 coil, spiral, volute, whorl, helix
+n03075370 combination lock
+n03085013 computer keyboard, keypad
+n03089624 confectionery, confectionary, candy store
+n03095699 container ship, containership, container vessel
+n03100240 convertible
+n03109150 corkscrew, bottle screw
+n03110669 cornet, horn, trumpet, trump
+n03124043 cowboy boot
+n03124170 cowboy hat, ten-gallon hat
+n03125729 cradle
+n03126707 crane
+n03127747 crash helmet
+n03127925 crate
+n03131574 crib, cot
+n03133878 Crock Pot
+n03134739 croquet ball
+n03141823 crutch
+n03146219 cuirass
+n03160309 dam, dike, dyke
+n03179701 desk
+n03180011 desktop computer
+n03187595 dial telephone, dial phone
+n03188531 diaper, nappy, napkin
+n03196217 digital clock
+n03197337 digital watch
+n03201208 dining table, board
+n03207743 dishrag, dishcloth
+n03207941 dishwasher, dish washer, dishwashing machine
+n03208938 disk brake, disc brake
+n03216828 dock, dockage, docking facility
+n03218198 dogsled, dog sled, dog sleigh
+n03220513 dome
+n03223299 doormat, welcome mat
+n03240683 drilling platform, offshore rig
+n03249569 drum, membranophone, tympan
+n03250847 drumstick
+n03255030 dumbbell
+n03259280 Dutch oven
+n03271574 electric fan, blower
+n03272010 electric guitar
+n03272562 electric locomotive
+n03290653 entertainment center
+n03291819 envelope
+n03297495 espresso maker
+n03314780 face powder
+n03325584 feather boa, boa
+n03337140 file, file cabinet, filing cabinet
+n03344393 fireboat
+n03345487 fire engine, fire truck
+n03347037 fire screen, fireguard
+n03355925 flagpole, flagstaff
+n03372029 flute, transverse flute
+n03376595 folding chair
+n03379051 football helmet
+n03384352 forklift
+n03388043 fountain
+n03388183 fountain pen
+n03388549 four-poster
+n03393912 freight car
+n03394916 French horn, horn
+n03400231 frying pan, frypan, skillet
+n03404251 fur coat
+n03417042 garbage truck, dustcart
+n03424325 gasmask, respirator, gas helmet
+n03425413 gas pump, gasoline pump, petrol pump, island dispenser
+n03443371 goblet
+n03444034 go-kart
+n03445777 golf ball
+n03445924 golfcart, golf cart
+n03447447 gondola
+n03447721 gong, tam-tam
+n03450230 gown
+n03452741 grand piano, grand
+n03457902 greenhouse, nursery, glasshouse
+n03459775 grille, radiator grille
+n03461385 grocery store, grocery, food market, market
+n03467068 guillotine
+n03476684 hair slide
+n03476991 hair spray
+n03478589 half track
+n03481172 hammer
+n03482405 hamper
+n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier
+n03485407 hand-held computer, hand-held microcomputer
+n03485794 handkerchief, hankie, hanky, hankey
+n03492542 hard disc, hard disk, fixed disk
+n03494278 harmonica, mouth organ, harp, mouth harp
+n03495258 harp
+n03496892 harvester, reaper
+n03498962 hatchet
+n03527444 holster
+n03529860 home theater, home theatre
+n03530642 honeycomb
+n03532672 hook, claw
+n03534580 hoopskirt, crinoline
+n03535780 horizontal bar, high bar
+n03538406 horse cart, horse-cart
+n03544143 hourglass
+n03584254 iPod
+n03584829 iron, smoothing iron
+n03590841 jack-o'-lantern
+n03594734 jean, blue jean, denim
+n03594945 jeep, landrover
+n03595614 jersey, T-shirt, tee shirt
+n03598930 jigsaw puzzle
+n03599486 jinrikisha, ricksha, rickshaw
+n03602883 joystick
+n03617480 kimono
+n03623198 knee pad
+n03627232 knot
+n03630383 lab coat, laboratory coat
+n03633091 ladle
+n03637318 lampshade, lamp shade
+n03642806 laptop, laptop computer
+n03649909 lawn mower, mower
+n03657121 lens cap, lens cover
+n03658185 letter opener, paper knife, paperknife
+n03661043 library
+n03662601 lifeboat
+n03666591 lighter, light, igniter, ignitor
+n03670208 limousine, limo
+n03673027 liner, ocean liner
+n03676483 lipstick, lip rouge
+n03680355 Loafer
+n03690938 lotion
+n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+n03692522 loupe, jeweler's loupe
+n03697007 lumbermill, sawmill
+n03706229 magnetic compass
+n03709823 mailbag, postbag
+n03710193 mailbox, letter box
+n03710637 maillot
+n03710721 maillot, tank suit
+n03717622 manhole cover
+n03720891 maraca
+n03721384 marimba, xylophone
+n03724870 mask
+n03729826 matchstick
+n03733131 maypole
+n03733281 maze, labyrinth
+n03733805 measuring cup
+n03742115 medicine chest, medicine cabinet
+n03743016 megalith, megalithic structure
+n03759954 microphone, mike
+n03761084 microwave, microwave oven
+n03763968 military uniform
+n03764736 milk can
+n03769881 minibus
+n03770439 miniskirt, mini
+n03770679 minivan
+n03773504 missile
+n03775071 mitten
+n03775546 mixing bowl
+n03776460 mobile home, manufactured home
+n03777568 Model T
+n03777754 modem
+n03781244 monastery
+n03782006 monitor
+n03785016 moped
+n03786901 mortar
+n03787032 mortarboard
+n03788195 mosque
+n03788365 mosquito net
+n03791053 motor scooter, scooter
+n03792782 mountain bike, all-terrain bike, off-roader
+n03792972 mountain tent
+n03793489 mouse, computer mouse
+n03794056 mousetrap
+n03796401 moving van
+n03803284 muzzle
+n03804744 nail
+n03814639 neck brace
+n03814906 necklace
+n03825788 nipple
+n03832673 notebook, notebook computer
+n03837869 obelisk
+n03838899 oboe, hautboy, hautbois
+n03840681 ocarina, sweet potato
+n03841143 odometer, hodometer, mileometer, milometer
+n03843555 oil filter
+n03854065 organ, pipe organ
+n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO
+n03866082 overskirt
+n03868242 oxcart
+n03868863 oxygen mask
+n03871628 packet
+n03873416 paddle, boat paddle
+n03874293 paddlewheel, paddle wheel
+n03874599 padlock
+n03876231 paintbrush
+n03877472 pajama, pyjama, pj's, jammies
+n03877845 palace
+n03884397 panpipe, pandean pipe, syrinx
+n03887697 paper towel
+n03888257 parachute, chute
+n03888605 parallel bars, bars
+n03891251 park bench
+n03891332 parking meter
+n03895866 passenger car, coach, carriage
+n03899768 patio, terrace
+n03902125 pay-phone, pay-station
+n03903868 pedestal, plinth, footstall
+n03908618 pencil box, pencil case
+n03908714 pencil sharpener
+n03916031 perfume, essence
+n03920288 Petri dish
+n03924679 photocopier
+n03929660 pick, plectrum, plectron
+n03929855 pickelhaube
+n03930313 picket fence, paling
+n03930630 pickup, pickup truck
+n03933933 pier
+n03935335 piggy bank, penny bank
+n03937543 pill bottle
+n03938244 pillow
+n03942813 ping-pong ball
+n03944341 pinwheel
+n03947888 pirate, pirate ship
+n03950228 pitcher, ewer
+n03954731 plane, carpenter's plane, woodworking plane
+n03956157 planetarium
+n03958227 plastic bag
+n03961711 plate rack
+n03967562 plow, plough
+n03970156 plunger, plumber's helper
+n03976467 Polaroid camera, Polaroid Land camera
+n03976657 pole
+n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+n03980874 poncho
+n03982430 pool table, billiard table, snooker table
+n03983396 pop bottle, soda bottle
+n03991062 pot, flowerpot
+n03992509 potter's wheel
+n03995372 power drill
+n03998194 prayer rug, prayer mat
+n04004767 printer
+n04005630 prison, prison house
+n04008634 projectile, missile
+n04009552 projector
+n04019541 puck, hockey puck
+n04023962 punching bag, punch bag, punching ball, punchball
+n04026417 purse
+n04033901 quill, quill pen
+n04033995 quilt, comforter, comfort, puff
+n04037443 racer, race car, racing car
+n04039381 racket, racquet
+n04040759 radiator
+n04041544 radio, wireless
+n04044716 radio telescope, radio reflector
+n04049303 rain barrel
+n04065272 recreational vehicle, RV, R.V.
+n04067472 reel
+n04069434 reflex camera
+n04070727 refrigerator, icebox
+n04074963 remote control, remote
+n04081281 restaurant, eating house, eating place, eatery
+n04086273 revolver, six-gun, six-shooter
+n04090263 rifle
+n04099969 rocking chair, rocker
+n04111531 rotisserie
+n04116512 rubber eraser, rubber, pencil eraser
+n04118538 rugby ball
+n04118776 rule, ruler
+n04120489 running shoe
+n04125021 safe
+n04127249 safety pin
+n04131690 saltshaker, salt shaker
+n04133789 sandal
+n04136333 sarong
+n04141076 sax, saxophone
+n04141327 scabbard
+n04141975 scale, weighing machine
+n04146614 school bus
+n04147183 schooner
+n04149813 scoreboard
+n04152593 screen, CRT screen
+n04153751 screw
+n04154565 screwdriver
+n04162706 seat belt, seatbelt
+n04179913 sewing machine
+n04192698 shield, buckler
+n04200800 shoe shop, shoe-shop, shoe store
+n04201297 shoji
+n04204238 shopping basket
+n04204347 shopping cart
+n04208210 shovel
+n04209133 shower cap
+n04209239 shower curtain
+n04228054 ski
+n04229816 ski mask
+n04235860 sleeping bag
+n04238763 slide rule, slipstick
+n04239074 sliding door
+n04243546 slot, one-armed bandit
+n04251144 snorkel
+n04252077 snowmobile
+n04252225 snowplow, snowplough
+n04254120 soap dispenser
+n04254680 soccer ball
+n04254777 sock
+n04258138 solar dish, solar collector, solar furnace
+n04259630 sombrero
+n04263257 soup bowl
+n04264628 space bar
+n04265275 space heater
+n04266014 space shuttle
+n04270147 spatula
+n04273569 speedboat
+n04275548 spider web, spider's web
+n04277352 spindle
+n04285008 sports car, sport car
+n04286575 spotlight, spot
+n04296562 stage
+n04310018 steam locomotive
+n04311004 steel arch bridge
+n04311174 steel drum
+n04317175 stethoscope
+n04325704 stole
+n04326547 stone wall
+n04328186 stopwatch, stop watch
+n04330267 stove
+n04332243 strainer
+n04335435 streetcar, tram, tramcar, trolley, trolley car
+n04336792 stretcher
+n04344873 studio couch, day bed
+n04346328 stupa, tope
+n04347754 submarine, pigboat, sub, U-boat
+n04350905 suit, suit of clothes
+n04355338 sundial
+n04355933 sunglass
+n04356056 sunglasses, dark glasses, shades
+n04357314 sunscreen, sunblock, sun blocker
+n04366367 suspension bridge
+n04367480 swab, swob, mop
+n04370456 sweatshirt
+n04371430 swimming trunks, bathing trunks
+n04371774 swing
+n04372370 switch, electric switch, electrical switch
+n04376876 syringe
+n04380533 table lamp
+n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle
+n04392985 tape player
+n04398044 teapot
+n04399382 teddy, teddy bear
+n04404412 television, television system
+n04409515 tennis ball
+n04417672 thatch, thatched roof
+n04418357 theater curtain, theatre curtain
+n04423845 thimble
+n04428191 thresher, thrasher, threshing machine
+n04429376 throne
+n04435653 tile roof
+n04442312 toaster
+n04443257 tobacco shop, tobacconist shop, tobacconist
+n04447861 toilet seat
+n04456115 torch
+n04458633 totem pole
+n04461696 tow truck, tow car, wrecker
+n04462240 toyshop
+n04465501 tractor
+n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+n04476259 tray
+n04479046 trench coat
+n04482393 tricycle, trike, velocipede
+n04483307 trimaran
+n04485082 tripod
+n04486054 triumphal arch
+n04487081 trolleybus, trolley coach, trackless trolley
+n04487394 trombone
+n04493381 tub, vat
+n04501370 turnstile
+n04505470 typewriter keyboard
+n04507155 umbrella
+n04509417 unicycle, monocycle
+n04515003 upright, upright piano
+n04517823 vacuum, vacuum cleaner
+n04522168 vase
+n04523525 vault
+n04525038 velvet
+n04525305 vending machine
+n04532106 vestment
+n04532670 viaduct
+n04536866 violin, fiddle
+n04540053 volleyball
+n04542943 waffle iron
+n04548280 wall clock
+n04548362 wallet, billfold, notecase, pocketbook
+n04550184 wardrobe, closet, press
+n04552348 warplane, military plane
+n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin
+n04554684 washer, automatic washer, washing machine
+n04557648 water bottle
+n04560804 water jug
+n04562935 water tower
+n04579145 whiskey jug
+n04579432 whistle
+n04584207 wig
+n04589890 window screen
+n04590129 window shade
+n04591157 Windsor tie
+n04591713 wine bottle
+n04592741 wing
+n04596742 wok
+n04597913 wooden spoon
+n04599235 wool, woolen, woollen
+n04604644 worm fence, snake fence, snake-rail fence, Virginia fence
+n04606251 wreck
+n04612504 yawl
+n04613696 yurt
+n06359193 web site, website, internet site, site
+n06596364 comic book
+n06785654 crossword puzzle, crossword
+n06794110 street sign
+n06874185 traffic light, traffic signal, stoplight
+n07248320 book jacket, dust cover, dust jacket, dust wrapper
+n07565083 menu
+n07579787 plate
+n07583066 guacamole
+n07584110 consomme
+n07590611 hot pot, hotpot
+n07613480 trifle
+n07614500 ice cream, icecream
+n07615774 ice lolly, lolly, lollipop, popsicle
+n07684084 French loaf
+n07693725 bagel, beigel
+n07695742 pretzel
+n07697313 cheeseburger
+n07697537 hotdog, hot dog, red hot
+n07711569 mashed potato
+n07714571 head cabbage
+n07714990 broccoli
+n07715103 cauliflower
+n07716358 zucchini, courgette
+n07716906 spaghetti squash
+n07717410 acorn squash
+n07717556 butternut squash
+n07718472 cucumber, cuke
+n07718747 artichoke, globe artichoke
+n07720875 bell pepper
+n07730033 cardoon
+n07734744 mushroom
+n07742313 Granny Smith
+n07745940 strawberry
+n07747607 orange
+n07749582 lemon
+n07753113 fig
+n07753275 pineapple, ananas
+n07753592 banana
+n07754684 jackfruit, jak, jack
+n07760859 custard apple
+n07768694 pomegranate
+n07802026 hay
+n07831146 carbonara
+n07836838 chocolate sauce, chocolate syrup
+n07860988 dough
+n07871810 meat loaf, meatloaf
+n07873807 pizza, pizza pie
+n07875152 potpie
+n07880968 burrito
+n07892512 red wine
+n07920052 espresso
+n07930864 cup
+n07932039 eggnog
+n09193705 alp
+n09229709 bubble
+n09246464 cliff, drop, drop-off
+n09256479 coral reef
+n09288635 geyser
+n09332890 lakeside, lakeshore
+n09399592 promontory, headland, head, foreland
+n09421951 sandbar, sand bar
+n09428293 seashore, coast, seacoast, sea-coast
+n09468604 valley, vale
+n09472597 volcano
+n09835506 ballplayer, baseball player
+n10148035 groom, bridegroom
+n10565667 scuba diver
+n11879895 rapeseed
+n11939491 daisy
+n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+n12144580 corn
+n12267677 acorn
+n12620546 hip, rose hip, rosehip
+n12768682 buckeye, horse chestnut, conker
+n12985857 coral fungus
+n12998815 agaric
+n13037406 gyromitra
+n13040303 stinkhorn, carrion fungus
+n13044778 earthstar
+n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+n13054560 bolete
+n13133613 ear, spike, capitulum
+n15075141 toilet tissue, toilet paper, bathroom tissue

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

inference-engine/ie_bridges/python/setup.py

@@ -0,0 +1,202 @@
+import subprocess
+from pathlib import Path
+import platform
+import sys
+from itertools import chain
+from distutils.command.build_py import build_py as _build_py
+from distutils.command.clean import clean as _clean
+
+import shutil
+from setuptools import setup, Extension, find_packages
+from setuptools.command.build_ext import build_ext as _build_ext
+from setuptools.command.install import install as _install
+
+IS_WINDOWS = (platform.system() == 'Windows')
+IS_DARWIN = (platform.system() == 'Darwin')
+IS_LINUX = (platform.system() == 'Linux')
+
+REQUIREMENTS_FILE = 'requirements.txt'
+PACKAGE_NAME = 'inference_engine'
+
+PACKAGE = Path(PACKAGE_NAME)
+C_LIB_NAME = '{}._C'.format(PACKAGE_NAME)
+
+_build_cmd = ['cmake', '--build', '.']
+
+INFERENCE_ENGINE_DIR = None
+BUNDLE_INFERENCE_ENGINE = False
+
+
+def parse_command_line_options(cls):
+    """Propagates command line options to sub-commands.
+    Allows to run install command with build_ext options"""
+
+    base_user_options = getattr(cls, 'user_options', [])
+    base_boolean_options = getattr(cls, 'boolean_options', [])
+    base_run = cls.run
+    base_init_options = cls.initialize_options
+
+    cls.user_options = base_user_options + [
+        ('copy-ie-libs', None, 'Copy Inference Engine Libraries to package directory'),
+        ('inference-engine-dir=', None, 'Path to Inference Engine directory')
+    ]
+
+    cls.boolean_options = base_boolean_options + [
+        'copy-ie-libs'
+    ]
+
+    def initialize_options(self):
+        self.copy_ie_libs = False
+        self.inference_engine_dir = None
+        base_init_options(self)
+
+    def run(self):
+        global  INFERENCE_ENGINE_DIR
+        global  BUNDLE_INFERENCE_ENGINE
+
+        if self.copy_ie_libs:
+            BUNDLE_INFERENCE_ENGINE = True
+
+        if self.inference_engine_dir:
+            INFERENCE_ENGINE_DIR = self.inference_engine_dir
+
+        base_run(self)
+
+    cls.initialize_options = initialize_options
+    cls.run = run
+    return cls
+
+
+@parse_command_line_options
+class install(_install):
+    pass
+
+
+@parse_command_line_options
+class build_py(_build_py):
+    pass
+
+
+@parse_command_line_options
+class build_ext(_build_ext):
+    def run(self):
+        if not self.extensions:
+            return
+
+        for i, ext in enumerate(self.extensions):
+            if ext.name == C_LIB_NAME:
+                self._build_cmake()
+                self.extensions.pop(i)
+                break
+
+        super().run()
+
+    def _build_cmake(self):
+        print("Building C++ extension")
+        if Path.cwd().joinpath("Makefile").is_file():
+            # in build directory, run make only
+            subprocess.call(_build_cmd)
+        else:
+            # compile extension library and
+            self.build_cmake_lib()
+        print("Built C++ extension")
+
+    def build_cmake_lib(self):
+        def save_call(*args, error_msg=None, **kwargs):
+            if subprocess.call(*args, **kwargs) != 0:
+                if error_msg:
+                    print(error_msg)
+                shutil.rmtree(tmp_build_dir.as_posix(), ignore_errors=True)
+                sys.exit(1)
+
+        tmp_build_dir = Path("tmp_build")
+        destination = Path(self.build_lib) / PACKAGE_NAME if not self.inplace else Path(PACKAGE_NAME)
+        tmp_build_dir.mkdir(exist_ok=False)
+
+        _python_executable_opt = ['-DPYTHON_EXECUTABLE={}'.format(sys.executable)]
+        _build_type_opt = ['-DCMAKE_BUILD_TYPE=Release']
+        _generator_opt = ['-G', 'NMake Makefiles' if IS_WINDOWS else "Unix Makefiles"]
+
+        _optional = []
+        if BUNDLE_INFERENCE_ENGINE:
+            _optional.append('-DCOPY_IE_LIBS=ON')
+
+        if INFERENCE_ENGINE_DIR:
+            _optional.append('-DInferenceEngine_DIR={}'.format(INFERENCE_ENGINE_DIR))
+
+        _cmake_cmd = list(chain(['cmake'], _generator_opt, _build_type_opt, _python_executable_opt, _optional, ['..']))
+
+        save_call(_cmake_cmd, cwd=tmp_build_dir.as_posix(), error_msg="Cmake generator failed")
+        save_call(_build_cmd, cwd=tmp_build_dir.as_posix(), error_msg="Build command failed")
+
+        build_ext.copy_compiled_libs(tmp_build_dir / PACKAGE_NAME, destination)
+        shutil.rmtree(tmp_build_dir.as_posix(), ignore_errors=False)
+
+    @staticmethod
+    def copy_compiled_libs(source_dir, destination):
+        extensions = ['so', 'dll', 'pyd']
+        for path in chain.from_iterable(source_dir.glob("*.%s" % ext) for ext in extensions):
+            shutil.copy(path.as_posix(), destination.as_posix())
+
+
+class clean(_clean):
+    def run(self):
+        shutil.rmtree("tmp_build", ignore_errors=True)
+        extensions = ['so', 'dll', 'pyd']
+        for path in chain.from_iterable(PACKAGE.glob("*.%s" % ext) for ext in extensions):
+            path.unlink()
+        super().run()
+
+
+def paths_to_str(paths):
+    return [p.as_posix() for p in paths]
+
+
+with open(REQUIREMENTS_FILE) as reqs:
+    requirements = set(reqs.read().splitlines())
+
+# do not spoil pre-installed opencv (in case it was built from source)
+_opencv_package = "opencv-python"
+try:
+    import cv2
+
+    if _opencv_package in requirements:
+        requirements.remove(_opencv_package)
+except ImportError:
+    requirements.add(_opencv_package)
+
+
+c_sources = [
+    PACKAGE / 'ie_driver.cpp',
+    PACKAGE / 'ie_driver.hpp',
+
+    PACKAGE / 'c_ie_driver.pxd',
+    PACKAGE / 'ie_driver.pyx',
+    PACKAGE / 'ie_driver.pxd',
+]
+
+extensions = [
+    Extension(C_LIB_NAME, paths_to_str(c_sources))
+]
+
+cmdclass = {
+    'build_ext': build_ext,
+    'build_py': build_py,
+    'clean': clean,
+    'install': install,
+}
+
+setup(
+    name="inference_engine",
+    version='0.1.1',
+    description='Python inference for Inference Engine',
+    packages=find_packages(exclude=['tests']),
+    package_data={PACKAGE_NAME: ['*.so', '*.dll', '*dylib*', '*.pyd']},
+    include_package_data=True,
+    ext_modules=extensions,
+    cmdclass=cmdclass,
+    author='', author_email='',
+    tests_require=['pytest'],
+    install_requires=list(requirements),
+    zip_safe=False,
+)

inference-engine/include/cldnn/cldnn_config.hpp

@@ -0,0 +1,61 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header for advanced hardware related properties for clDNN plugin
+ *        To use in SetConfig() method of plugins
+ *
+ * @file ie_plugin_config.hpp
+ */
+#pragma once
+
+#include <string>
+#include "../ie_plugin_config.hpp"
+
+namespace InferenceEngine {
+
+namespace CLDNNConfigParams {
+
+/**
+* @brief shortcut for defining configuration keys
+*/
+#define CLDNN_CONFIG_KEY(name) InferenceEngine::CLDNNConfigParams::_CONFIG_KEY(CLDNN_##name)
+#define DECLARE_CLDNN_CONFIG_KEY(name) DECLARE_CONFIG_KEY(CLDNN_##name)
+#define DECLARE_CLDNN_CONFIG_VALUE(name) DECLARE_CONFIG_VALUE(CLDNN_##name)
+
+/**
+* @brief This key instructs the clDNN plugin to use the OpenCL queue priority hint
+* as defined in https://www.khronos.org/registry/OpenCL/specs/opencl-2.1-extensions.pdf
+* this option should be used with an unsigned integer value (1 is lowest priority)
+* 0 means no priority hint is set and default queue is created.
+*/
+DECLARE_CLDNN_CONFIG_KEY(PLUGIN_PRIORITY);
+
+/**
+* @brief This key instructs the clDNN plugin to use throttle hints the OpenCL queue throttle hint
+* as defined in https://www.khronos.org/registry/OpenCL/specs/opencl-2.1-extensions.pdf,
+* chapter 9.19. This option should be used with an unsigned integer value (1 is lowest energy consumption)
+* 0 means no throttle hint is set and default queue created.
+*/
+DECLARE_CLDNN_CONFIG_KEY(PLUGIN_THROTTLE);
+
+/**
+* @brief This key controls clDNN memory pool optimization.
+* Turned off by default.
+*/
+DECLARE_CLDNN_CONFIG_KEY(MEM_POOL);
+
+/**
+* @brief This key defines the directory name to which clDNN graph visualization will be dumped.
+*/
+DECLARE_CLDNN_CONFIG_KEY(GRAPH_DUMPS_DIR);
+
+/**
+* @brief This key defines the directory name to which full program sources will be dumped.
+*/
+DECLARE_CLDNN_CONFIG_KEY(SOURCES_DUMPS_DIR);
+
+}  // namespace CLDNNConfigParams
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_cnn_net_reader.h

@@ -0,0 +1,122 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file for the Network reader class (wrapper) used to build networks from a given IR
+ * @file ie_cnn_net_reader.h
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include <memory>
+#include <map>
+#include "ie_blob.h"
+#include "ie_cnn_network.h"
+#include "ie_common.h"
+#include "ie_icnn_net_reader.h"
+#include "details/ie_exception_conversion.hpp"
+
+namespace InferenceEngine {
+/**
+ * @brief This is a wrapper class used to build and parse a network from the given IR.
+ * All the methods here can throw exceptions.
+ */
+class CNNNetReader {
+public:
+    /**
+     * @brief A smart pointer to this class
+     */
+    using Ptr = std::shared_ptr<CNNNetReader>;
+
+    /**
+     * @brief A default constructor
+     */
+    CNNNetReader() : actual(shared_from_irelease(InferenceEngine::CreateCNNNetReader())) {}
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::ReadNetwork
+     */
+    void ReadNetwork(const std::string &filepath) {
+        CALL_STATUS_FNC(ReadNetwork, filepath.c_str());
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::ReadNetwork(const void*, size_t, ResponseDesc*)
+     */
+    void ReadNetwork(const void *model, size_t size) {
+        CALL_STATUS_FNC(ReadNetwork, model, size);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::SetWeights
+     */
+    void SetWeights(const TBlob<uint8_t>::Ptr &weights) const {
+        CALL_STATUS_FNC(SetWeights, weights);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::ReadWeights
+     */
+    void ReadWeights(const std::string &filepath) const {
+        CALL_STATUS_FNC(ReadWeights, filepath.c_str());
+    }
+
+    /**
+    * @brief Gets a copy of built network object
+    * @return A copy of the CNNNetwork object to be loaded
+     */
+    CNNNetwork getNetwork() {
+        // network obj are to be updated upon this call
+        if (network.get() == nullptr) {
+            network.reset(new CNNNetwork(actual));
+        }
+        return *network.get();
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::isParseSuccess
+     */
+    bool isParseSuccess() const {
+        CALL_FNC_NO_ARGS(isParseSuccess);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::getDescription
+     */
+    std::string getDescription() const {
+        CALL_STATUS_FNC_NO_ARGS(getDescription);
+        return resp.msg;
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::getName
+     */
+    std::string getName() const {
+        char name[64];
+        CALL_STATUS_FNC(getName, name, sizeof(name) / sizeof(*name));
+        return name;
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetReader::getVersion
+     */
+    int getVersion() const {
+        CALL_FNC_NO_ARGS(getVersion);
+    }
+
+private:
+    std::shared_ptr<ICNNNetReader> actual;
+    std::shared_ptr<CNNNetwork> network;
+};
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_cnn_network.h

@@ -0,0 +1,234 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides wrapper for ICNNNetwork object
+ * @file ie_cnn_network.h
+ */
+#pragma once
+
+#include <details/ie_exception_conversion.hpp>
+#include <details/ie_cnn_network_iterator.hpp>
+#include <ie_icnn_network.hpp>
+#include <ie_icnn_net_reader.h>
+#include "ie_common.h"
+#include "ie_data.h"
+#include "ie_blob.h"
+#include <vector>
+#include <string>
+#include <map>
+#include <utility>
+#include <memory>
+
+namespace InferenceEngine {
+
+/**
+ * @brief This class contains all the information about the Neural Network and the related binary information
+ */
+class CNNNetwork {
+public:
+    /**
+     * @brief A default constructor
+     */
+    CNNNetwork() = default;
+
+    /**
+     * @brief Initialises helper class from externally managed pointer
+     * @deprecated use shared_pointers based version of CNNNetworks constructor
+     * @param actual Pointer to the network object
+     */
+    explicit CNNNetwork(ICNNNetwork* actual) : actual(actual) {
+        if (actual == nullptr) {
+            THROW_IE_EXCEPTION << "CNNNetwork was not initialized.";
+        }
+    }
+
+    /**
+     * @brief Allows helper class to manage lifetime of network object
+     * @param network Pointer to the network object
+     */
+    explicit CNNNetwork(std::shared_ptr<ICNNNetwork> network)
+        : network(network) {
+        actual = network.get();
+        if (actual == nullptr) {
+            THROW_IE_EXCEPTION << "CNNNetwork was not initialized.";
+        }
+    }
+
+    /**
+     * @brief A constructor from ICNNNetReader object
+     * @param reader Pointer to the ICNNNetReader object
+     */
+    explicit CNNNetwork(std::shared_ptr<ICNNNetReader> reader)
+            : reader(reader)
+            , actual(reader->getNetwork(nullptr)) {
+        if (actual == nullptr) {
+            THROW_IE_EXCEPTION << "CNNNetwork was not initialized.";
+        }
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::getPrecision
+     */
+    virtual Precision getPrecision() const {
+        return actual->getPrecision();
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::getOutputsInfo
+     */
+    virtual OutputsDataMap getOutputsInfo() const {
+        OutputsDataMap outputs;
+        actual->getOutputsInfo(outputs);
+        return std::move(outputs);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::getInputsInfo
+     */
+    virtual InputsDataMap getInputsInfo() const {
+        InputsDataMap inputs;
+        actual->getInputsInfo(inputs);
+        return std::move(inputs);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::layerCount
+     */
+    size_t layerCount() const {
+        return actual->layerCount();
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::setBatchSize
+     */
+    virtual void setBatchSize(const size_t size) {
+        CALL_STATUS_FNC(setBatchSize, size);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::getBatchSize
+     */
+    virtual size_t getBatchSize() const {
+        return actual->getBatchSize();
+    }
+
+    /**
+     * @brief An overloaded operator & to get current network
+     * @return An instance of the current network
+     */
+    operator ICNNNetwork &() const {
+        return *actual;
+    }
+
+    /**
+     * @brief Sets tha target device
+     * @param device Device instance to set
+     */
+    void setTargetDevice(TargetDevice device) {
+        actual->setTargetDevice(device);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::addOutput
+     */
+    void addOutput(const std::string &layerName, size_t outputIndex = 0) {
+        CALL_STATUS_FNC(addOutput, layerName, outputIndex);
+    }
+
+    /**
+     * @brief Wraps original method
+     * ICNNNetwork::getLayerByName
+     */
+    CNNLayerPtr getLayerByName(const char *layerName) const {
+        CNNLayerPtr layer;
+        CALL_STATUS_FNC(getLayerByName, layerName, layer);
+        return layer;
+    }
+
+    /**
+     * @brief Begin layer iterator
+     * Order of layers is implementation specific,
+     * and can be changed in future
+     */
+    details::CNNNetworkIterator begin() const {
+        return details::CNNNetworkIterator(actual);
+    }
+
+    /**
+     * @brief End layer iterator
+     */
+    details::CNNNetworkIterator end() const {
+        return details::CNNNetworkIterator();
+    }
+
+    /**
+     * @brief number of layers in network object
+     * @return
+     */
+    size_t size() const {
+        return std::distance(std::begin(*this), std::end(*this));
+    }
+
+    /**
+     * @brief Registers extension within the plugin
+     * @param extension Pointer to already loaded reader extension with shape propagation implementations
+     */
+    void AddExtension(InferenceEngine::IShapeInferExtensionPtr extension) {
+        CALL_STATUS_FNC(AddExtension, extension);
+    }
+
+    /**
+     * @brief - Helper method to get collect all input shapes with names of corresponding Data objects
+     * @return Map of pairs: input's name and its dimension.
+     */
+    virtual ICNNNetwork::InputShapes getInputShapes() {
+        ICNNNetwork::InputShapes shapes;
+        InputsDataMap inputs;
+        actual->getInputsInfo(inputs);
+        for (const auto& pair : inputs) {
+            auto info = pair.second;
+            if (info) {
+                auto data = info->getInputData();
+                if (data) {
+                    shapes[data->name] = data->getTensorDesc().getDims();
+                }
+            }
+        }
+        return std::move(shapes);
+    }
+
+    virtual void reshape(const ICNNNetwork::InputShapes &inputShapes) {
+        CALL_STATUS_FNC(reshape, inputShapes);
+    }
+
+protected:
+    /**
+     * @brief reader extra reference, might be nullptr
+     */
+    std::shared_ptr<ICNNNetReader> reader;
+    /**
+     * @brief network extra interface, might be nullptr
+     */
+    std::shared_ptr<ICNNNetwork> network;
+
+    /**
+     * @brief A pointer to the current network
+     */
+    ICNNNetwork *actual = nullptr;
+    /**
+     * @brief A pointer to output data
+     */
+    DataPtr output;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_executable_network.hpp

@@ -0,0 +1,137 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides wrapper classes for IExecutableNetwork
+ * @file ie_executable_network.hpp
+ */
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+#include <memory>
+#include <algorithm>
+#include "ie_iexecutable_network.hpp"
+#include "cpp/ie_infer_request.hpp"
+#include "cpp/ie_memory_state.hpp"
+#include "details/ie_exception_conversion.hpp"
+
+namespace InferenceEngine {
+
+/**
+ * @brief wrapper over IExecutableNetwork
+ */
+class ExecutableNetwork {
+    IExecutableNetwork::Ptr actual;
+
+public:
+    ExecutableNetwork() = default;
+
+    explicit ExecutableNetwork(IExecutableNetwork::Ptr actual) : actual(actual) {}
+
+    /**
+     * @brief Wraps original method
+     * IExecutableNetwork::getOutputsInfo
+     */
+    ConstOutputsDataMap GetOutputsInfo() const {
+        ConstOutputsDataMap data;
+        CALL_STATUS_FNC(GetOutputsInfo, data);
+        return data;
+    }
+
+    /**
+     * @brief Wraps original method
+     * IExecutableNetwork::getInputsInfo
+     */
+    ConstInputsDataMap GetInputsInfo() const {
+        ConstInputsDataMap info;
+        CALL_STATUS_FNC(GetInputsInfo, info);
+        return info;
+    }
+
+    /**
+     * @brief reset owned object to new pointer, essential for cases when simultaneously loaded networks not expected
+     * @param actual actual pointed object
+     */
+    void reset(IExecutableNetwork::Ptr newActual) {
+        this->actual.swap(newActual);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IExecutableNetwork::CreateInferRequest
+     */
+    InferRequest CreateInferRequest() {
+        IInferRequest::Ptr req;
+        CALL_STATUS_FNC(CreateInferRequest, req);
+        if (req.get() == nullptr) THROW_IE_EXCEPTION << "Internal error: pointer to infer request is null";
+        return InferRequest(req);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IExecutableNetwork::CreateInferRequestPtr
+     * @return shared pointer on InferRequest object
+     */
+    InferRequest::Ptr CreateInferRequestPtr() {
+        IInferRequest::Ptr req;
+        CALL_STATUS_FNC(CreateInferRequest, req);
+        return std::make_shared<InferRequest>(req);
+    }
+
+    /**
+    * @brief Exports the current executable network so it can be used later in the Import() main API
+    * @param modelFileName Full path to the location of the exported file
+    * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+    */
+    void Export(const std::string &modelFileName) {
+        CALL_STATUS_FNC(Export, modelFileName);
+    }
+
+    /**
+    * @brief Gets the mapping of IR layer names to implemented kernels
+    * @param deployedTopology Map of PrimitiveInfo objects that represent the deployed topology
+    * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+    */
+    void GetMappedTopology(std::map<std::string, std::vector<PrimitiveInfo::Ptr>> &deployedTopology) {
+        CALL_STATUS_FNC(GetMappedTopology, deployedTopology);
+    }
+
+    /**
+    * cast operator is used when this wrapper initialized by LoadNetwork
+    * @return
+    */
+    operator IExecutableNetwork::Ptr &() {
+        return actual;
+    }
+
+
+    /**
+     *@brief see original function InferenceEngine::IExecutableNetwork::QueryState
+     */
+    std::vector<MemoryState> QueryState() {
+        IMemoryState::Ptr pState = nullptr;
+        auto res = OK;
+        std::vector<MemoryState> controller;
+        for (size_t idx = 0; res == OK; ++idx) {
+            ResponseDesc resp;
+            res = actual->QueryState(pState, idx, &resp);
+            if (res != OK && res != OUT_OF_BOUNDS) {
+                THROW_IE_EXCEPTION << resp.msg;
+            }
+            if (res != OUT_OF_BOUNDS) {
+                controller.push_back(MemoryState(pState));
+            }
+        }
+
+        return controller;
+    }
+
+
+    using Ptr = std::shared_ptr<ExecutableNetwork>;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_infer_request.hpp

@@ -0,0 +1,218 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides wrapper classes for infer requests and callbacks.
+ * @file ie_infer_request.hpp
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+#include <map>
+#include "ie_iinfer_request.hpp"
+#include "details/ie_exception_conversion.hpp"
+
+namespace InferenceEngine {
+
+namespace details {
+
+class ICompletionCallbackWrapper {
+public:
+    virtual ~ICompletionCallbackWrapper() = default;
+
+    virtual void call(InferenceEngine::IInferRequest::Ptr request, InferenceEngine::StatusCode code) const noexcept = 0;
+};
+
+template<class T>
+class CompletionCallbackWrapper : public ICompletionCallbackWrapper {
+    T lambda;
+public:
+    explicit CompletionCallbackWrapper(const T &lambda) : lambda(lambda) {}
+
+    void call(InferenceEngine::IInferRequest::Ptr /*request*/,
+              InferenceEngine::StatusCode /*code*/) const noexcept override {
+        lambda();
+    }
+};
+
+template<>
+class CompletionCallbackWrapper<IInferRequest::CompletionCallback> : public ICompletionCallbackWrapper {
+    IInferRequest::CompletionCallback callBack;
+public:
+    explicit CompletionCallbackWrapper(const IInferRequest::CompletionCallback &callBack) : callBack(callBack) {}
+
+    void call(InferenceEngine::IInferRequest::Ptr request, InferenceEngine::StatusCode code) const noexcept override {
+        callBack(request, code);
+    }
+};
+
+}  // namespace details
+
+/**
+ * @brief This class is a wrapper of IInferRequest to provide setters/getters
+ * of input/output which operates with BlobMaps.
+ * It can throw exceptions safely for the application, where it is properly handled.
+ */
+class InferRequest {
+    IInferRequest::Ptr actual;
+    std::shared_ptr<details::ICompletionCallbackWrapper> callback;
+
+    static void callWrapper(InferenceEngine::IInferRequest::Ptr request, InferenceEngine::StatusCode code) {
+        details::ICompletionCallbackWrapper *pWrapper = nullptr;
+        ResponseDesc dsc;
+        request->GetUserData(reinterpret_cast<void**>(&pWrapper), &dsc);
+        pWrapper->call(request, code);
+    }
+
+public:
+    InferRequest() = default;
+
+    /**
+     * @brief Sets input/output data to infer
+     * @note: Memory allocation does not happen
+     * @param name Name of input or output blob.
+     * @param data Reference to input or output blob. The type of a blob must match the network input precision and size.
+     */
+    void SetBlob(const std::string &name, const Blob::Ptr &data) {
+        CALL_STATUS_FNC(SetBlob, name.c_str(), data);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferRequest::GetBlob
+     */
+    Blob::Ptr GetBlob(const std::string &name) {
+        Blob::Ptr data;
+        CALL_STATUS_FNC(GetBlob, name.c_str(), data);
+        std::string error = "Internal error: blob with name `" + name + "` is not allocated!";
+        auto blobPtr = data.get();
+        if (blobPtr == nullptr) THROW_IE_EXCEPTION << error;
+        if (blobPtr->buffer() == nullptr) THROW_IE_EXCEPTION << error;
+        return data;
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferRequest::Infer
+     */
+    void Infer() {
+        CALL_STATUS_FNC_NO_ARGS(Infer);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferRequest::GetPerformanceCounts
+     */
+    std::map<std::string, InferenceEngineProfileInfo> GetPerformanceCounts() const {
+        std::map<std::string, InferenceEngineProfileInfo> perfMap;
+        CALL_STATUS_FNC(GetPerformanceCounts, perfMap);
+        return perfMap;
+    }
+
+    /**
+     * @brief Sets input data to infer
+     * @note: Memory allocation doesn't happen
+     * @param inputs - a reference to a map of input blobs accessed by input names.
+     *        The type of Blob must correspond to the network input precision and size.
+     */
+    void SetInput(const BlobMap &inputs) {
+        for (auto &&input : inputs) {
+            CALL_STATUS_FNC(SetBlob, input.first.c_str(), input.second);
+        }
+    }
+
+    /**
+     * @brief Sets data that will contain result of the inference
+     * @note: Memory allocation doesn't happen
+     * @param results - a reference to a map of result blobs accessed by output names.
+     *        The type of Blob must correspond to the network output precision and size.
+     */
+    void SetOutput(const BlobMap &results) {
+        for (auto &&result : results) {
+            CALL_STATUS_FNC(SetBlob, result.first.c_str(), result.second);
+        }
+    }
+
+    /**
+    * @brief Sets data that will contain result of the inference
+    * @param results - a reference to a map of result blobs accessed by output names.
+    *        The type of Blob must correspond to the network output precision and size.
+    */
+    void SetBatch(const int batch) {
+        CALL_STATUS_FNC(SetBatch, batch);
+    }
+
+    /**
+     * constructs InferRequest from initialised shared_pointer
+     * @param actual
+     */
+    explicit InferRequest(IInferRequest::Ptr request) : actual(request) {}
+
+    /**
+     * @brief Start inference of specified input(s) in asynchronous mode
+     * @note: It returns immediately. Inference starts also immediately.
+     */
+    void StartAsync() {
+        CALL_STATUS_FNC_NO_ARGS(StartAsync);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferRequest::Wait
+     */
+    StatusCode Wait(int64_t millis_timeout) {
+        return actual->Wait(millis_timeout, nullptr);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferRequest::SetCompletionCallback
+     *
+     * @param callbackToSet Lambda callback object which will be called on processing finish.
+     */
+    template <class T>
+    void SetCompletionCallback(const T & callbackToSet) {
+        callback.reset(new details::CompletionCallbackWrapper<T>(callbackToSet));
+        CALL_STATUS_FNC(SetUserData, callback.get());
+        actual->SetCompletionCallback(callWrapper);
+    }
+
+    /**
+     * @brief  IInferRequest pointer to be used directly in CreateInferRequest functions
+     */
+    operator IInferRequest::Ptr &() {
+        return actual;
+    }
+
+    bool operator!() const noexcept {
+        return !actual;
+    }
+
+    explicit operator bool() const noexcept {
+        return !!actual;
+    }
+
+    using Ptr = std::shared_ptr<InferRequest>;
+};
+
+namespace details {
+
+template<>
+class CompletionCallbackWrapper<std::function<void(InferRequest, StatusCode)>>
+        : public ICompletionCallbackWrapper {
+    std::function<void(InferRequest, StatusCode)> lambda;
+public:
+    explicit CompletionCallbackWrapper(const std::function<void(InferRequest, InferenceEngine::StatusCode)> &lambda)
+            : lambda(lambda) {}
+
+    void call(InferenceEngine::IInferRequest::Ptr request,
+              InferenceEngine::StatusCode code) const noexcept override {
+        lambda(InferRequest(request), code);
+    }
+};
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_memory_state.hpp

@@ -0,0 +1,54 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+#include <string>
+
+namespace InferenceEngine {
+
+/**
+ * @brief c++ exception based error reporting wrapper of API class IMemoryState
+ */
+class MemoryState {
+    IMemoryState::Ptr actual = nullptr;
+
+ public:
+    explicit MemoryState(IMemoryState::Ptr pState) : actual(pState) {}
+
+    /**
+     * @brief Wraps original method
+     * IMemoryState::Reset
+     */
+     void Reset() {
+        CALL_STATUS_FNC_NO_ARGS(Reset);
+     }
+    /**
+     * @brief Wraps original method
+     * IMemoryState::GetName
+     */
+     std::string GetName() const {
+         char name[256];
+         CALL_STATUS_FNC(GetName, name, sizeof(name));
+         return name;
+     }
+    /**
+     * @brief Wraps original method
+     * IMemoryState::GetLastState
+     */
+      Blob::CPtr GetLastState() const {
+         Blob::CPtr stateBlob;
+         CALL_STATUS_FNC(GetLastState, stateBlob);
+         return stateBlob;
+     }
+    /**
+     * @brief Wraps original method
+     * IMemoryState::SetState
+     */
+     void SetState(Blob::Ptr state) {
+         CALL_STATUS_FNC(SetState, state);
+     }
+};
+
+}  // namespace InferenceEngine

inference-engine/include/cpp/ie_plugin_cpp.hpp

@@ -0,0 +1,162 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file for the Inference Engine plugin C++ API
+ * @file ie_plugin_cpp.hpp
+ */
+#pragma once
+
+#include <map>
+#include <string>
+#include <memory>
+
+#include "ie_plugin.hpp"
+#include "details/ie_exception_conversion.hpp"
+#include "cpp/ie_executable_network.hpp"
+#include "ie_plugin_ptr.hpp"
+#include "ie_cnn_network.h"
+
+
+namespace InferenceEngine {
+
+/**
+ * @brief This class is a C++ API wrapper for IInferencePlugin.
+ * It can throw exceptions safely for the application, where it is properly handled.
+ */
+class InferencePlugin {
+    InferenceEnginePluginPtr actual;
+
+public:
+    /** @brief A default constructor */
+    InferencePlugin() = default;
+
+    /**
+     * @brief Constructs a plugin instance from the given pointer.
+     */
+    explicit InferencePlugin(const InferenceEnginePluginPtr &pointer) : actual(pointer) {}
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::GetVersion
+     */
+    const Version *GetVersion() {
+        const Version *versionInfo = nullptr;
+        actual->GetVersion(versionInfo);
+        return versionInfo;
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::LoadNetwork
+     */
+    void LoadNetwork(ICNNNetwork &network) {
+        CALL_STATUS_FNC(LoadNetwork, network);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::LoadNetwork(IExecutableNetwork::Ptr&, ICNNNetwork&, const std::map<std::string, std::string> &, ResponseDesc*).
+     */
+    ExecutableNetwork LoadNetwork(ICNNNetwork &network, const std::map<std::string, std::string> &config) {
+        IExecutableNetwork::Ptr ret;
+        CALL_STATUS_FNC(LoadNetwork, ret, network, config);
+        return ExecutableNetwork(ret);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::LoadNetwork(IExecutableNetwork::Ptr&, ICNNNetwork&, const std::map<std::string, std::string> &, ResponseDesc*).
+     */
+    ExecutableNetwork LoadNetwork(CNNNetwork network, const std::map<std::string, std::string> &config) {
+        IExecutableNetwork::Ptr ret;
+        CALL_STATUS_FNC(LoadNetwork, ret, network, config);
+        if (ret.get() == nullptr) THROW_IE_EXCEPTION << "Internal error: pointer to executable network is null";
+        return ExecutableNetwork(ret);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::Infer(const BlobMap&, BlobMap&, ResponseDesc *resp)
+     */
+    void Infer(const BlobMap &input, BlobMap &result) {
+        CALL_STATUS_FNC(Infer, input, result);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::GetPerformanceCounts
+     */
+    std::map<std::string, InferenceEngineProfileInfo> GetPerformanceCounts() const {
+        std::map<std::string, InferenceEngineProfileInfo> perfMap;
+        CALL_STATUS_FNC(GetPerformanceCounts, perfMap);
+        return perfMap;
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::AddExtension
+     */
+    void AddExtension(InferenceEngine::IExtensionPtr extension) {
+        CALL_STATUS_FNC(AddExtension, extension);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::SetConfig
+     */
+    void SetConfig(const std::map<std::string, std::string> &config) {
+        CALL_STATUS_FNC(SetConfig, config);
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::ImportNetwork
+    */
+    ExecutableNetwork  ImportNetwork(const std::string &modelFileName, const std::map<std::string, std::string> &config) {
+        IExecutableNetwork::Ptr ret;
+        CALL_STATUS_FNC(ImportNetwork, ret, modelFileName, config);
+        return ExecutableNetwork(ret);
+    }
+
+    /**
+     * @depricated Use the version with config parameter
+     * @brief Wraps original method
+     * IInferencePlugin::QueryNetwork
+     */
+    void QueryNetwork(const ICNNNetwork &network, QueryNetworkResult &res) const {
+        actual->QueryNetwork(network, res);
+        if (res.rc != OK) THROW_IE_EXCEPTION << res.resp.msg;
+    }
+
+    /**
+     * @brief Wraps original method
+     * IInferencePlugin::QueryNetwork
+     */
+    void QueryNetwork(const ICNNNetwork &network, const std::map<std::string, std::string> &config, QueryNetworkResult &res) const {
+        actual->QueryNetwork(network, config, res);
+        if (res.rc != OK) THROW_IE_EXCEPTION << res.resp.msg;
+    }
+
+    /**
+     * @brief Returns wrapped object
+     */
+    operator InferenceEngine::InferenceEnginePluginPtr() {
+        return actual;
+    }
+
+    /**
+    * @return wrapped Hetero object if underlined object is HeteroPlugin instance, nullptr otherwise
+    */
+    operator InferenceEngine::HeteroPluginPtr() {
+        return actual;
+    }
+
+    /**
+     * @brief Shared pointer on InferencePlugin object
+     */
+    using Ptr = std::shared_ptr<InferencePlugin>;
+};
+}  // namespace InferenceEngine

inference-engine/include/details/ie_blob_iterator.hpp

@@ -0,0 +1,86 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for the BlobIterator class
+ * @file ie_blob_iterator.hpp
+ */
+
+#include "ie_locked_memory.hpp"
+#include <utility>
+
+namespace InferenceEngine {
+namespace details {
+/**
+ * @brief This class provides range loops support for TBlob objects
+ */
+template<class T>
+class BlobIterator {
+    LockedMemory<T> _mem;
+    size_t _offset;
+
+public:
+    /**
+     * @brief A move constructor to create a BlobIterator instance from a LockedMemory instance.
+     * Explicitly rejects implicit conversions.
+     * @param lk Rvalue of the memory instance to move from
+     * @param offset Size of offset in memory
+     */
+    explicit BlobIterator(LockedMemory<T> &&lk, size_t offset = 0)
+            : _mem(std::move(lk)), _offset(offset) {
+    }
+
+    /**
+     * @brief Increments an offset of the current BlobIterator instance
+     * @return The current BlobIterator instance
+     */
+    BlobIterator &operator++() {
+        _offset++;
+        return *this;
+    }
+
+    /**
+     * @brief An overloaded postfix incrementation operator
+     * Implementation does not follow std interface since only move semantics is used
+     */
+    void operator++(int) {
+        _offset++;
+    }
+
+    /**
+     * @brief Checks if the given iterator is not equal to the current one
+     * @param that Iterator to compare with
+     * @return true if the given iterator is not equal to the current one, false - otherwise
+     */
+    bool operator!=(const BlobIterator &that) const {
+        return !operator==(that);
+    }
+
+    /**
+     * @brief Gets a value by the pointer to the current iterator
+     * @return The value stored in memory for the current offset value
+     */
+    const T &operator*() const {
+        return *(_mem.template as<const T *>() + _offset);
+    }
+
+    /**
+     * @brief Gets a value by the pointer to the current iterator
+     * @return The value stored in memory for the current offset value
+     */
+    T &operator*() {
+        return *(_mem.template as<T *>() + _offset);
+    }
+    /**
+     * @brief Compares the given iterator with the current one
+     * @param that Iterator to compare with
+     * @return true if the given iterator is equal to the current one, false - otherwise
+     */
+    bool operator==(const BlobIterator &that) const {
+        return &operator*() == &that.operator*();
+    }
+};
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_cnn_network_iterator.hpp

@@ -0,0 +1,151 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for the CNNNetworkIterator class
+ * @file ie_cnn_network_iterator.hpp
+ */
+#pragma once
+#include <utility>
+#include <unordered_set>
+#include <list>
+#include <iterator>
+
+#include "ie_locked_memory.hpp"
+#include "ie_icnn_network.hpp"
+
+namespace InferenceEngine {
+namespace details {
+
+/**
+ * @brief This class enables range loops for CNNNetwork objects
+ */
+class CNNNetworkIterator {
+    std::unordered_set<CNNLayer*> visited;
+    std::list<CNNLayerPtr> nextLayersTovisit;
+    InferenceEngine::CNNLayerPtr currentLayer;
+    ICNNNetwork * network = nullptr;
+
+ public:
+    /**
+     * iterator trait definitions
+     */
+    typedef std::forward_iterator_tag iterator_category;
+    typedef CNNLayerPtr value_type;
+    typedef int         difference_type;
+    typedef CNNLayerPtr pointer;
+    typedef CNNLayerPtr reference;
+
+    /**
+     * @brief Default constructor
+     */
+    CNNNetworkIterator() = default;
+    /**
+     * @brief Constructor. Creates an iterator for specified CNNNetwork instance.
+     * @param network Network to iterate. Make sure the network object is not destroyed before iterator goes out of scope.
+     */
+    explicit CNNNetworkIterator(ICNNNetwork * network) {
+        InputsDataMap inputs;
+        network->getInputsInfo(inputs);
+        if (!inputs.empty()) {
+            auto & nextLayers = inputs.begin()->second->getInputData()->getInputTo();
+            if (!nextLayers.empty()) {
+                currentLayer = nextLayers.begin()->second;
+                nextLayersTovisit.push_back(currentLayer);
+                visited.insert(currentLayer.get());
+            }
+        }
+    }
+
+    /**
+     * @brief Performs pre-increment 
+     * @return This CNNNetworkIterator instance
+     */
+    CNNNetworkIterator &operator++() {
+        currentLayer = next();
+        return *this;
+    }
+
+    /**
+     * @brief Performs post-increment.
+     * Implementation does not follow the std interface since only move semantics is used
+     */
+    void operator++(int) {
+        currentLayer = next();
+    }
+
+    /**
+     * @brief Checks if the given iterator is not equal to this one
+     * @param that Iterator to compare with
+     * @return true if the given iterator is not equal to this one, false - otherwise
+     */
+    bool operator!=(const CNNNetworkIterator &that) const {
+        return !operator==(that);
+    }
+
+    /**
+     * @brief Gets const layer pointer referenced by this iterator
+     */
+    const CNNLayerPtr &operator*() const {
+        if (nullptr == currentLayer) {
+            THROW_IE_EXCEPTION << "iterator of ouf bound";
+        }
+        return currentLayer;
+    }
+
+    /**
+     * @brief Gets a layer pointer referenced by this iterator
+     */
+    CNNLayerPtr &operator*() {
+        if (nullptr == currentLayer) {
+            THROW_IE_EXCEPTION << "iterator out of bound";
+        }
+        return currentLayer;
+    }
+    /**
+     * @brief Compares the given iterator with this one
+     * @param that Iterator to compare with
+     * @return true if the given iterator is equal to this one, false - otherwise
+     */
+    bool operator==(const CNNNetworkIterator &that) const {
+        return network == that.network && currentLayer == that.currentLayer;
+    }
+
+ private:
+    /**
+     * @brief implementation based on BFS
+     */
+    CNNLayerPtr next() {
+        if (nextLayersTovisit.empty()) {
+            return nullptr;
+        }
+
+        auto nextLayer = nextLayersTovisit.front();
+        nextLayersTovisit.pop_front();
+
+        // visit child that not visited
+        for (auto && output : nextLayer->outData) {
+            for (auto && child : output->getInputTo()) {
+                if (visited.find(child.second.get()) == visited.end()) {
+                    nextLayersTovisit.push_back(child.second);
+                    visited.insert(child.second.get());
+                }
+            }
+        }
+
+        // visit parents
+        for (auto && parent  : nextLayer->insData) {
+            auto parentLayer = parent.lock()->getCreatorLayer().lock();
+            if (parentLayer && visited.find(parentLayer.get()) == visited.end()) {
+                nextLayersTovisit.push_back(parentLayer);
+                visited.insert(parentLayer.get());
+            }
+        }
+
+        return nextLayersTovisit.empty() ? nullptr : nextLayersTovisit.front();
+    }
+};
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_exception.hpp

@@ -0,0 +1,154 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for the main Inference Engine exception
+ * \file ie_exception.hpp
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+#include <sstream>
+#include <vector>
+#include <functional>
+#include <utility>
+
+/**
+ * @def THROW_IE_EXCEPTION
+ * @brief A macro used to throw the exception with a notable description
+ */
+#define THROW_IE_EXCEPTION\
+    throw InferenceEngine::details::InferenceEngineException(__FILE__, __LINE__)\
+
+/**
+ * @def IE_ASSERT
+ * @brief Uses assert() function if NDEBUG is not defined, InferenceEngine exception otherwise
+ */
+#ifdef NDEBUG
+    #define IE_ASSERT(EXPRESSION)\
+    if (!(EXPRESSION)) throw InferenceEngine::details::InferenceEngineException(__FILE__, __LINE__) << "AssertionFailed: " << #EXPRESSION  // NOLINT
+#else
+#include <cassert>
+#define IE_ASSERT(EXPRESSION)\
+    assert((EXPRESSION)); std::stringstream()
+#endif  // NDEBUG
+
+namespace InferenceEngine {
+enum StatusCode: int;
+namespace details {
+
+/**
+ * @brief The InferenceEngineException class implements the main Inference Engine exception
+ */
+class InferenceEngineException : public std::exception {
+    mutable std::string errorDesc;
+    StatusCode status_code = static_cast<StatusCode>(0);
+    std::string _file;
+    int _line;
+    std::shared_ptr<std::stringstream> exception_stream;
+    bool save_to_status_code = false;
+
+public:
+    /**
+     * @brief A C++ std::exception API member
+     * @return An exception description with a file name and file line
+     */
+    const char *what() const noexcept override {
+        if (errorDesc.empty() && exception_stream) {
+            errorDesc = exception_stream->str();
+#ifndef NDEBUG
+            errorDesc +=  "\n" + _file + ":" + std::to_string(_line);
+#endif
+        }
+        return errorDesc.c_str();
+    }
+
+    /**
+     * @brief A constructor. Creates an InferenceEngineException object from a specific file and line
+     * @param filename File where exception has been thrown
+     * @param line Line of the exception emitter
+     */
+    InferenceEngineException(const std::string &filename, const int line)
+        : _file(filename), _line(line) {
+    }
+
+    /**
+     * @brief noexcept required for copy ctor
+     * @details The C++ Standard, [except.throw], paragraph 3 [ISO/IEC 14882-2014]
+     */
+    InferenceEngineException(const InferenceEngineException & that) noexcept {
+        errorDesc = that.errorDesc;
+        status_code = that.status_code;
+        _file = that._file;
+        _line = that._line;
+        exception_stream = that.exception_stream;
+    }
+
+    /**
+     * @brief A stream output operator to be used within exception
+     * @param arg Object for serialization in the exception message
+     */
+    template<class T>
+    InferenceEngineException& operator<<(const T &arg) {
+        if (save_to_status_code) {
+            auto can_convert =  status_code_assign(arg);
+            save_to_status_code = false;
+            if (can_convert.second) {
+                this->status_code = can_convert.first;
+                return *this;
+            }
+        }
+        if (!exception_stream) {
+            exception_stream.reset(new std::stringstream());
+        }
+        (*exception_stream) << arg;
+        return *this;
+    }
+
+    /**
+     * @brief Manipulator to indicate that next item has to be converted to StatusCode to save
+     * @param iex InferenceEngineException object
+     */
+    friend InferenceEngineException& as_status(InferenceEngineException& iex) {
+        iex.save_to_status_code = true;
+        return iex;
+    }
+
+    /**
+     * @brief A stream output operator to catch InferenceEngineException manipulators
+     * @param manip InferenceEngineException manipulator to call
+     */
+    InferenceEngineException& operator<<(InferenceEngineException& (*manip)(InferenceEngineException &)) {
+        return manip(*this);
+    }
+
+    /**  @brief Check if it has StatusCode value */
+    bool hasStatus() const {
+        return this->status_code == 0 ? false : true;
+    }
+
+    /** @brief Get StatusCode value */
+    StatusCode getStatus() const {
+        return this->status_code;
+    }
+
+private:
+    std::pair<StatusCode, bool> status_code_assign(const StatusCode& status) {
+        return {status, true};
+    }
+
+    template <typename T>
+    std::pair<StatusCode, bool> status_code_assign(const T & arg) {
+        return {static_cast<StatusCode>(0), false};
+    }
+};
+
+InferenceEngineException& as_status(InferenceEngineException& iex);
+
+static_assert(std::is_nothrow_copy_constructible<InferenceEngineException>::value,
+              "InferenceEngineException must be nothrow copy constructible");
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_exception_conversion.hpp

@@ -0,0 +1,76 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides macros to handle no exception methods
+ * @file ie_exception_conversion.hpp
+ */
+#pragma once
+#include <ie_common.h>
+
+#define CALL_STATUS_FNC(function, ...)\
+ResponseDesc resp;\
+auto res = actual->function(__VA_ARGS__, &resp);\
+if (res != OK) InferenceEngine::details::extract_exception(res, resp.msg);
+
+#define CALL_STATUS_FNC_NO_ARGS(function)\
+ResponseDesc resp;\
+auto res = actual->function(&resp);\
+if (res != OK) InferenceEngine::details::extract_exception(res, resp.msg);
+
+
+#define CALL_FNC(function, ...)\
+ResponseDesc resp;\
+auto result = actual->function(__VA_ARGS__, &resp);\
+if (resp.msg[0] != '\0') {\
+    THROW_IE_EXCEPTION << resp.msg;\
+}\
+return result;
+
+#define CALL_FNC_REF(function, ...)\
+ResponseDesc resp;\
+auto & result = actual->function(__VA_ARGS__, &resp);\
+if (resp.msg[0] != '\0') {\
+    THROW_IE_EXCEPTION << resp.msg;\
+}\
+return result;
+
+#define CALL_FNC_NO_ARGS(function)\
+ResponseDesc resp;\
+auto result = actual->function(&resp);\
+if (resp.msg[0] != '\0') {\
+    THROW_IE_EXCEPTION << resp.msg;\
+}\
+return result;
+
+#define CALL_FNC_NO_ARGS_REF(function)\
+ResponseDesc resp;\
+auto & result = actual->function(&resp);\
+if (resp.msg[0] != '\0') {\
+    THROW_IE_EXCEPTION << resp.msg;\
+}\
+return result;
+
+namespace InferenceEngine {
+namespace details {
+
+inline void extract_exception(StatusCode status, char *msg) {
+    switch (status) {
+        case NOT_IMPLEMENTED:throw NotImplemented(msg);
+        case NETWORK_NOT_LOADED:throw NetworkNotLoaded(msg);
+        case PARAMETER_MISMATCH:throw ParameterMismatch(msg);
+        case NOT_FOUND:throw NotFound(msg);
+        case OUT_OF_BOUNDS:throw OutOfBounds(msg);
+        case UNEXPECTED:throw Unexpected(msg);
+        case REQUEST_BUSY:throw RequestBusy(msg);
+        case RESULT_NOT_READY:throw ResultNotReady(msg);
+        case NOT_ALLOCATED:throw NotAllocated(msg);
+        case INFER_NOT_STARTED:throw InferNotStarted(msg);
+        default:THROW_IE_EXCEPTION << msg;
+    }
+}
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_irelease.hpp

@@ -0,0 +1,45 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for the Inference Engine plugins destruction mechanism
+ * @file ie_irelease.hpp
+ */
+#pragma once
+
+#include "ie_no_copy.hpp"
+#include <memory>
+
+namespace InferenceEngine {
+namespace details {
+/**
+ * @brief This class is used for objects allocated by a shared module (in *.so)
+ */
+class IRelease : public no_copy {
+public:
+    /**
+     * @brief Releases current allocated object and all related resources.
+     * Once this method is called, the pointer to this interface is no longer valid
+     */
+    virtual void Release() noexcept = 0;
+
+ protected:
+    /**
+     * @brief Default destructor
+     */
+    ~IRelease() override = default;
+};
+
+
+
+template <class T> inline std::shared_ptr<T> shared_from_irelease(T * ptr) {
+    std::shared_ptr<T> pointer(ptr, [](IRelease *p) {
+        p->Release();
+    });
+    return pointer;
+}
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_no_copy.hpp

@@ -0,0 +1,50 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief header file for no_copy class
+ * @file ie_no_copy.hpp
+ */
+#pragma once
+
+namespace InferenceEngine {
+namespace details {
+/**
+ * @brief This class is used for objects returned from the shared library factory to prevent copying
+ */
+class no_copy {
+protected:
+    /**
+     * @brief A default constructor
+     */
+    no_copy() = default;
+
+    /**
+     * @brief A default destructor
+     */
+    virtual ~no_copy() = default;
+
+    /**
+     * @brief A removed copy constructor
+     */
+    no_copy(no_copy const &) = delete;
+
+    /**
+     * @brief A removed assign operator
+     */
+    no_copy &operator=(no_copy const &) = delete;
+
+    /**
+     * @brief A removed move constructor
+     */
+    no_copy(no_copy &&) = delete;
+
+    /**
+     * @brief A removed move operator
+     */
+    no_copy &operator=(no_copy &&) = delete;
+};
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_no_release.hpp

@@ -0,0 +1,25 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief Utility header file. Provides no release base class
+ * @file ie_no_release.hpp
+ */
+#pragma  once
+
+namespace  InferenceEngine {
+namespace details {
+
+/**
+ * @brief prevent Release method from being called on specific objects
+ */
+template<class T>
+class NoReleaseOn : public T {
+ private :
+    void Release() noexcept = 0;
+};
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_pre_allocator.hpp

@@ -0,0 +1,87 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief The header file defines utility PreAllocator class
+ * @file ie_pre_allocator.hpp
+ */
+#pragma once
+
+#include <details/ie_exception.hpp>
+#include "ie_allocator.hpp"
+#include <memory>
+
+namespace InferenceEngine {
+namespace details {
+/*
+ * @brief This is a helper class to wrap external memory
+ */
+class PreAllocator : public IAllocator {
+    void * _actualData;
+    size_t _sizeInBytes;
+
+ public:
+    PreAllocator(void *ptr, size_t bytes_size)
+        : _actualData(ptr), _sizeInBytes(bytes_size) {}
+    /**
+     * @brief Locks a handle to heap memory accessible by any memory manipulation routines
+     * @return The generic pointer to a memory buffer
+     */
+    void * lock(void * handle, LockOp = LOCK_FOR_WRITE)  noexcept override {
+        if (handle != _actualData) {
+            return nullptr;
+        }
+        return handle;
+    }
+    /**
+     * @brief The PreAllocator class does not utilize this function
+     * @param handle Memory handle to unlock
+     */
+    void  unlock(void * handle) noexcept override {}
+
+    /**
+     * @brief Returns a pointer to preallocated memory
+     * @param size Size in bytes
+     * @return A handle to the preallocated memory or nullptr
+     */
+    void * alloc(size_t size) noexcept override {
+        if (size <= _sizeInBytes) {
+            return _actualData;
+        }
+
+        return this;
+    }
+    /**
+     * @brief The PreAllocator class cannot release the handle
+     * @param handle Memory handle to release
+     * @return false
+     */
+    bool   free(void* handle) noexcept override { return false;}
+
+    /**
+     * @brief Deletes current allocator. 
+     * Can be used if a shared_from_irelease pointer is used
+     */
+    void Release() noexcept override {
+        delete this;
+    }
+
+ protected:
+    virtual ~PreAllocator() = default;
+};
+
+/**
+ * @brief Creates a special allocator that only works on external memory
+ * @param ptr Pointer to preallocated memory
+ * @param size Number of elements allocated
+ * @return A new allocator
+ */
+template <class T>
+std::shared_ptr<IAllocator>  make_pre_allocator(T *ptr, size_t size) {
+    return shared_from_irelease(new PreAllocator(ptr, size * sizeof(T)));
+}
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/ie_so_loader.h

@@ -0,0 +1,16 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for definition of abstraction over platform specific shared objects
+ * @file ie_so_loader.h
+ */
+#pragma once
+
+#ifndef _WIN32
+    #include "os/lin_shared_object_loader.h"
+#else
+    #include "os/win_shared_object_loader.h"
+#endif

inference-engine/include/details/ie_so_pointer.hpp

@@ -0,0 +1,166 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+* @brief This is a wrapper class for handling plugin instantiation and releasing resources
+* @file ie_so_pointer.hpp
+*/
+#pragma once
+
+#include <memory>
+#include "ie_so_loader.h"
+#include "ie_common.h"
+#include "ie_plugin.hpp"
+#include "details/ie_exception.hpp"
+#include "details/ie_no_release.hpp"
+#include <string>
+#include <cassert>
+
+namespace InferenceEngine {
+namespace details {
+
+/**
+* @brief This class is a C++ helper to load a symbol from a library and create its instance
+*/
+template<class Loader>
+class SymbolLoader {
+private:
+    std::shared_ptr<Loader> _so_loader;
+
+public:
+    /**
+    * @brief The main constructor
+    * @param loader Library to load from
+    */
+    explicit SymbolLoader(std::shared_ptr<Loader> loader) : _so_loader(loader) {}
+
+    /**
+    * @brief Calls a function from the library that creates an object and returns StatusCode
+    * @param name Name of function to load object with
+    * @return If StatusCode provided by function is OK then returns the loaded object. Throws an exception otherwise
+    */
+    template<class T>
+    T* instantiateSymbol(const std::string& name) const {
+        T* instance = nullptr;
+        ResponseDesc desc;
+        StatusCode sts = bind_function<StatusCode(T*&, ResponseDesc*)>(name)(instance, &desc);
+        if (sts != OK) {
+            THROW_IE_EXCEPTION << desc.msg;
+        }
+        return instance;
+    }
+
+    /**
+    * @brief Loads function from the library and returns a pointer to it
+    * @param functionName Name of function to load
+    * @return The loaded function
+    */
+    template<class T>
+    std::function<T> bind_function(const std::string &functionName) const {
+        std::function<T> ptr(reinterpret_cast<T *>(_so_loader->get_symbol(functionName.c_str())));
+        return ptr;
+    }
+};
+
+/**
+* @brief This class is a trait class that provides a creator with a function name corresponding to the templated class parameter
+*/
+template<class T>
+class SOCreatorTrait {};
+
+/**
+* @brief This class instantiate object using shared library
+*/
+template <class T, class Loader = SharedObjectLoader>
+class SOPointer {
+    template <class U, class W> friend class SOPointer;
+public:
+    /**
+    * @brief Default constructor
+    */
+    SOPointer() = default;
+
+    /**
+    * @brief The main constructor
+    * @param name Name of a shared library file
+    */
+    explicit SOPointer(const std::string &name)
+        : _so_loader(new Loader(name.c_str()))
+        , _pointedObj(details::shared_from_irelease(
+            SymbolLoader<Loader>(_so_loader).template instantiateSymbol<T>(SOCreatorTrait<T>::name))) {
+    }
+
+    /**
+    * @brief The copy-like constructor, can create So Pointer that dereferenced into child type if T is derived of U
+    * @param that copied SOPointer object
+    */
+    template<class U, class W>
+    SOPointer(const SOPointer<U, W> & that) :
+        _so_loader(std::dynamic_pointer_cast<Loader>(that._so_loader)),
+        _pointedObj(std::dynamic_pointer_cast<T>(that._pointedObj)) {
+    }
+
+    /**
+    * @brief Standard pointer operator
+    * @return underlined interface with disabled Release method
+    */
+    details::NoReleaseOn<T>* operator->() const noexcept {
+        return reinterpret_cast<details::NoReleaseOn<T>*>(_pointedObj.get());
+    }
+
+    /**
+    * @brief Standard dereference operator
+    * @return underlined interface with disabled Release method
+    */
+    details::NoReleaseOn<T>* operator*() const noexcept {
+        return this->operator->();
+    }
+
+    explicit operator bool() const noexcept {
+        return (nullptr != _so_loader) && (nullptr != _pointedObj);
+    }
+
+    friend bool operator == (std::nullptr_t, const SOPointer& ptr) noexcept {
+        return !ptr;
+    }
+    friend bool operator == (const SOPointer& ptr, std::nullptr_t) noexcept {
+        return !ptr;
+    }
+    friend bool operator != (std::nullptr_t, const SOPointer& ptr) noexcept {
+        return static_cast<bool>(ptr);
+    }
+    friend bool operator != (const SOPointer& ptr, std::nullptr_t) noexcept {
+        return static_cast<bool>(ptr);
+    }
+
+    SOPointer& operator=(const SOPointer & pointer) noexcept {
+        _pointedObj =  pointer._pointedObj;
+        _so_loader = pointer._so_loader;
+        return *this;
+    }
+
+protected:
+    /**
+     * @brief Gets a smart pointer to the DLL
+     */
+    std::shared_ptr<Loader> _so_loader;
+    /**
+     * @brief Gets a smart pointer to the custom object
+     */
+    std::shared_ptr<T> _pointedObj;
+};
+
+}  // namespace details
+
+
+
+/**
+ * @brief Creates a special shared_pointer wrapper for the given type from a specific shared module
+ * @param name Name of the shared library file
+ */
+template <class T>
+inline std::shared_ptr<T> make_so_pointer(const std::string & name) = delete;
+
+}  // namespace InferenceEngine

inference-engine/include/details/os/lin_shared_object_loader.h

@@ -0,0 +1,62 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief POSIX compatible loader for a shared object
+ * @file lin_shared_object_loader.h
+ */
+#pragma once
+
+#include <dlfcn.h>
+
+#include "../../ie_api.h"
+#include "../ie_exception.hpp"
+
+namespace InferenceEngine {
+namespace details {
+
+/**
+ * @brief This class provides an OS shared module abstraction
+ */
+class SharedObjectLoader {
+private:
+    void *shared_object = nullptr;
+
+public:
+    /**
+     * @brief Loads a library with the name specified. The library is loaded according to
+     *        the POSIX rules for dlopen
+     * @param pluginName Full or relative path to the library
+     */
+    explicit SharedObjectLoader(const char* pluginName) {
+        shared_object = dlopen(pluginName, RTLD_LAZY);
+
+        if (shared_object == nullptr)
+            THROW_IE_EXCEPTION << "Cannot load library '" << pluginName << "': " << dlerror();
+    }
+    ~SharedObjectLoader() noexcept(false) {
+        if (0 != dlclose(shared_object)) {
+            THROW_IE_EXCEPTION << "dlclose failed: " << dlerror();
+        }
+    }
+
+    /**
+     * @brief Searches for a function symbol in the loaded module
+     * @param symbolName Name of the function to find
+     * @return A pointer to the function if found
+     * @throws InferenceEngineException if the function is not found
+     */
+    void *get_symbol(const char* symbolName) const {
+        void * procAddr = nullptr;
+
+        procAddr = dlsym(shared_object, symbolName);
+        if (procAddr == nullptr)
+            THROW_IE_EXCEPTION << "dlSym cannot locate method '" << symbolName << "': " << dlerror();
+        return procAddr;
+    }
+};
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/details/os/win_shared_object_loader.h

@@ -0,0 +1,71 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief WINAPI compatible loader for a shared object
+ * @file win_shared_object_loader.h
+ */
+#pragma once
+
+#include "../../ie_api.h"
+#include "../ie_exception.hpp"
+
+// Avoidance of Windows.h to include winsock library.
+#define _WINSOCKAPI_
+// Avoidance of Windows.h to define min/max.
+#define NOMINMAX
+#include <windows.h>
+#include <direct.h>
+
+namespace InferenceEngine {
+namespace details {
+
+/**
+ * @brief This class provides an OS shared module abstraction
+ */
+class SharedObjectLoader {
+private:
+    HMODULE shared_object;
+
+ public:
+    /**
+     * @brief Loads a library with the name specified. The library is loaded according to the
+     *        WinAPI LoadLibrary rules
+     * @param pluginName Full or relative path to the plugin library
+     */
+    explicit SharedObjectLoader(const char* pluginName) {
+        char cwd[1024];
+        shared_object = LoadLibrary(pluginName);
+        if (!shared_object) {
+            THROW_IE_EXCEPTION << "Cannot load library '"
+                << pluginName << "': "
+                << GetLastError()
+                << " from cwd: " << _getcwd(cwd, 1024);
+        }
+    }
+    ~SharedObjectLoader() {
+        FreeLibrary(shared_object);
+    }
+
+    /**
+     * @brief Searches for a function symbol in the loaded module
+     * @param symbolName Name of function to find
+     * @return A pointer to the function if found
+     * @throws InferenceEngineException if the function is not found
+     */
+    void *get_symbol(const char* symbolName) const {
+        if (!shared_object) {
+            THROW_IE_EXCEPTION << "Cannot get '" << symbolName << "' content from unknown library!";
+        }
+        auto procAddr = reinterpret_cast<void*>(GetProcAddress(shared_object, symbolName));
+        if (procAddr == nullptr)
+            THROW_IE_EXCEPTION << "GetProcAddress cannot locate method '" << symbolName << "': " << GetLastError();
+
+        return procAddr;
+    }
+};
+
+}  // namespace details
+}  // namespace InferenceEngine

inference-engine/include/hetero/hetero_plugin_config.hpp

@@ -0,0 +1,34 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header that defines advanced related properties for Heterogeneous plugins.
+ * These properties should be used in SetConfig() and LoadNetwork() methods of plugins
+ *
+ * @file hetero_plugin_config.hpp
+ */
+
+#pragma once
+
+#include <string>
+#include "../ie_plugin_config.hpp"
+
+namespace InferenceEngine {
+
+namespace HeteroConfigParams {
+
+#define HETERO_CONFIG_KEY(name) InferenceEngine::HeteroConfigParams::_CONFIG_KEY(HETERO_##name)
+#define DECLARE_HETERO_CONFIG_KEY(name) DECLARE_CONFIG_KEY(HETERO_##name)
+#define DECLARE_HETERO_CONFIG_VALUE(name) DECLARE_CONFIG_VALUE(HETERO_##name)
+
+/**
+ * @brief The key for enabling of dumping the topology with details of layers and details how
+ * this network would be executed on different devices to the disk in GraphViz format.
+ * This option should be used with values: CONFIG_VALUE(NO) (default) or CONFIG_VALUE(YES)
+ */
+DECLARE_HETERO_CONFIG_KEY(DUMP_GRAPH_DOT);
+
+}  // namespace HeteroConfigParams
+}  // namespace InferenceEngine

inference-engine/include/ie_allocator.hpp

@@ -0,0 +1,66 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides Allocator interface
+ * @file ie_allocator.hpp
+ */
+#pragma once
+
+#include <details/ie_irelease.hpp>
+#include <ie_api.h>
+
+namespace InferenceEngine {
+
+/**
+ * @brief Allocator handle mapping type
+ */
+enum LockOp {
+    LOCK_FOR_READ = 0,
+    LOCK_FOR_WRITE
+};
+
+/**
+ * @brief Allocator concept to be used for memory management and is used as part of the Blob.
+ */
+class IAllocator  : public details::IRelease {
+public:
+    /**
+     * @brief Maps handle to heap memory accessible by any memory manipulation routines.
+     * @return Generic pointer to memory
+     */
+    virtual void * lock(void * handle, LockOp = LOCK_FOR_WRITE)  noexcept = 0;
+    /**
+     * @brief Unmaps memory by handle with multiple sequential mappings of the same handle.
+     * The multiple sequential mappings of the same handle are suppose to get the same
+     * result while there isn't a ref counter supported.
+     */
+    virtual void  unlock(void * handle) noexcept = 0;
+    /**
+     * @brief Allocates memory
+     * @param size The size in bytes to allocate
+     * @return Handle to the allocated resource
+     */
+    virtual void * alloc(size_t size) noexcept = 0;
+    /**
+     * @brief Releases handle and all associated memory resources which invalidates the handle.
+     * @return false if handle cannot be released, otherwise - true.
+     */
+    virtual bool   free(void* handle) noexcept = 0;
+
+ protected:
+    /**
+     * @brief Disables the ability of deleting the object without release.
+     */
+    ~IAllocator()override = default;
+};
+
+/**
+ * @brief Creates the default implementation of the Inference Engine allocator per plugin.
+ * @return The Inference Engine IAllocator* instance
+ */
+INFERENCE_ENGINE_API(InferenceEngine::IAllocator*)CreateDefaultAllocator() noexcept;
+
+}  // namespace InferenceEngine

inference-engine/include/ie_api.h

@@ -0,0 +1,30 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief The macro defines a symbol import/export mechanism essential for Microsoft Windows(R) OS.
+ * @file ie_api.h
+ */
+#pragma once
+
+#include "details/ie_no_copy.hpp"
+
+#if defined(_WIN32) && !defined(USE_STATIC_IE)
+    #define INFERENCE_ENGINE_CDECL
+    #ifdef IMPLEMENT_INFERENCE_ENGINE_API
+            #define INFERENCE_ENGINE_API(type) extern "C"   __declspec(dllexport) type __cdecl
+            #define INFERENCE_ENGINE_API_CPP(type)  __declspec(dllexport) type __cdecl
+            #define INFERENCE_ENGINE_API_CLASS(type)        __declspec(dllexport) type
+    #else
+            #define INFERENCE_ENGINE_API(type) extern "C"  __declspec(dllimport) type __cdecl
+            #define INFERENCE_ENGINE_API_CPP(type)  __declspec(dllimport) type __cdecl
+            #define INFERENCE_ENGINE_API_CLASS(type)   __declspec(dllimport) type
+    #endif
+#else
+#define INFERENCE_ENGINE_API(TYPE) extern "C" TYPE
+#define INFERENCE_ENGINE_API_CPP(type) type
+#define INFERENCE_ENGINE_API_CLASS(type)    type
+#define INFERENCE_ENGINE_CDECL __attribute__((cdecl))
+#endif

inference-engine/include/ie_blob.h

@@ -0,0 +1,778 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for Blob and generic TBlob<>
+ * @file ie_blob.h
+ */
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <string>
+#include <numeric>
+#include <cstring>
+#include <utility>
+#include <functional>
+#include <map>
+
+#include "ie_common.h"
+#include "details/ie_exception.hpp"
+#include "details/ie_blob_iterator.hpp"
+#include "ie_allocator.hpp"
+#include "ie_locked_memory.hpp"
+#include "ie_precision.hpp"
+#include "ie_layouts.h"
+#include "details/ie_pre_allocator.hpp"
+
+namespace InferenceEngine {
+/**
+ * @brief This class implements a container object that represents a tensor in memory (host and remote/accelerated)
+ */
+class Blob {
+public:
+    /**
+     * @brief A smart pointer containing Blob object
+     */
+    using Ptr = std::shared_ptr<Blob>;
+
+    /**
+     * @brief A smart pointer to the const Blob object
+     */
+    using CPtr = std::shared_ptr<const Blob>;
+
+    /**
+     * @deprecated Please use TensorDesc to get the precision
+     * @brief Returns the tensor precision of the current Blob object
+     */
+    Precision type() const noexcept {
+        return tensorDesc.getPrecision();
+    }
+
+    /**
+     * @deprecated Please use TensorDesc to get the precision
+     * @brief Returns the tensor precision of the current Blob object
+     */
+    Precision precision() const noexcept {
+        return tensorDesc.getPrecision();
+    }
+
+    /**
+     * @deprecated Please use TensorDesc to get the current layout
+     * @brief Returns the tensor layout of the current Blob object
+     */
+    Layout layout() const noexcept {
+        return tensorDesc.getLayout();
+    }
+
+    /**
+     * @brief Creates a TBlob<> object from a Data node
+     * @param Data reference to a smart pointer of the Data node
+     * @return Smart pointer to TBlob<> with the relevant C type to the precision of the data node
+     */
+    static Ptr CreateFromData(const DataPtr &data);
+
+    /**
+     * @brief Blob virtual destructor
+     */
+    virtual ~Blob()  = default;
+
+    /**
+     * @brief Constructor. Creates an empty Blob object with the specified precision.
+     * @param tensorDesc Defines the layout and dims of the blob
+     */
+    explicit Blob(TensorDesc tensorDesc): tensorDesc(tensorDesc) {}
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization
+     * @brief Constructor. Creates an empty Blob object with the specified precision.
+     * @param p Precision type
+     */
+    explicit Blob(Precision p) : Blob(p, NCHW) {}
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization
+     * @brief The constructor creates an empty Blob object with the specified precision and layout.
+     * @param p Precision type
+     * @param l Layout
+     */
+    Blob(Precision p, Layout l) : tensorDesc(p, l) {}
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization
+     * @brief The constructor creates an empty Blob object with the specified precision and dimensions.
+     * @param p Tensor precision type
+     * @param dims Tensor dimensions vector
+     */
+    Blob(Precision p, const SizeVector &dims)
+            : Blob(p, TensorDesc::getLayoutByDims(dims), dims) {}
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization
+     * @brief The constructor creates an empty Blob object with the specified precision, layout and dimensions.
+     * @param p tensor precision type
+     * @param l tensor layout
+     * @param dims Tensor dimensions vector with reversed order
+     */
+    Blob(Precision p, Layout l, const SizeVector &dims)
+            : tensorDesc(p, SizeVector(dims.rbegin(), dims.rend()), l) {}
+
+    /**
+     * @depricated It works with reversed dimensions. Please create a new blob if you want to change a size.
+     * @brief Changes Tensor size to the specified dimensions. If it was allocated, the previous data is deallocated and lost.
+     * @param dims New dimensions to set
+     * @param layout New layout to set
+     * @return Total number of elements (a product of all the dimensions)
+     */
+    size_t Resize(const SizeVector &dims, Layout layout = Layout::ANY) {
+        bool bret = deallocate();
+
+        if (layout != Layout::ANY) {
+            tensorDesc = TensorDesc(tensorDesc.getPrecision(), SizeVector(dims.rbegin(), dims.rend()), layout);
+        } else {
+            tensorDesc.setDims(SizeVector(dims.rbegin(), dims.rend()));
+        }
+        if (!bret) {
+            allocate();
+        }
+        return product(tensorDesc.getDims());
+    }
+
+    /**
+     * @deprecated It works with reversed dimensions. Please use TensorDescriptor.reshape().
+     * @brief Changes tensor size to the specified dimensions without changing memory. The total size remains unchanged as well as the memory layout.
+     * @param dims New dimensions to set
+     * @param layout New layout to set
+     * @return The total number of elements (a product of all the dims)
+     */
+    size_t Reshape(const SizeVector &dims, Layout layout = Layout::ANY) {
+        if (product(tensorDesc.getDims()) != product(dims)) {
+            THROW_IE_EXCEPTION << "cannot reshape when total size changes";
+        }
+
+        if (layout != Layout::ANY) {
+            tensorDesc = TensorDesc(tensorDesc.getPrecision(), SizeVector(dims.rbegin(), dims.rend()), layout);
+        } else {
+            tensorDesc.setDims(SizeVector(dims.rbegin(), dims.rend()));
+        }
+        return product(tensorDesc.getDims());
+    }
+
+    /**
+     * @deprecated Please use TensorDesc for working with dimensions.
+     * @brief Returns the tensor dimensions vector with reversed order.
+     */
+    const SizeVector dims() const {
+        return SizeVector(tensorDesc.getDims().rbegin(), tensorDesc.getDims().rend());
+    }
+
+    /**
+     * @brief Returns the tensor description
+     */
+    const TensorDesc &getTensorDesc() const {
+        return tensorDesc;
+    }
+
+    /**
+     * @brief Returns the total number of elements (a product of all the dims)
+     */
+    size_t size() const {
+        return product(tensorDesc.getDims());
+    }
+
+    /**
+     * @brief Returns the size of the current Blob in bytes.
+     */
+    size_t byteSize() const {
+        return product(tensorDesc.getDims()) * element_size();
+    }
+
+    /**
+     * @brief Returns the number of bytes per element. The overall Blob capacity is size() * element_size().
+     * Abstract method.
+     */
+    virtual size_t element_size() const noexcept = 0;
+
+    /**
+     * @brief Allocates memory to store the data.
+     * Abstract method.
+     */
+    virtual void allocate() = 0;
+
+    /**
+     * @brief Releases previously allocated data.
+     * Abstract method.
+     */
+    virtual bool deallocate() = 0;
+
+    /**
+     * @brief Gets access to the allocated memory.
+     * Abstract method.
+     * @return A LockedMemory object
+     */
+    virtual LockedMemory<void> buffer() = 0;
+
+    /**
+     * @brief Gets read-only access to the allocated memory.
+     * Abstract method.
+     * @return A LockedMemory object
+     */
+    virtual LockedMemory<const void> cbuffer() const = 0;
+
+protected:
+    /**
+     * @brief The tensor descriptor of the given blob.
+     */
+    TensorDesc tensorDesc;
+
+    /**
+     * @brief Multiplies the dimension vector's values.
+     * @param dims Reference to a vector with dimension values of type size_t
+     * @return Result of multiplication
+     */
+    static size_t product(const SizeVector &dims) {
+        if (dims.empty())
+            return 0;
+        return std::accumulate(std::begin(dims), std::end(dims), (size_t) 1, std::multiplies<size_t>());
+    }
+
+    /**
+    * @brief Gets the allocator for allocator-based blobs.
+    * @return The allocator for allocator-based blobs or if there is none then a nullptr.
+    */
+    virtual const std::shared_ptr<IAllocator> &getAllocator() const noexcept  = 0;
+
+    /**
+    * @brief Gets the handle to allocated memory.
+    * @return The handle to allocated memory for allocator-based blobs or if there is none then a nullptr.
+    */
+    virtual void *getHandle() const noexcept  = 0;
+
+    template<typename> friend
+    class TBlobProxy;
+};
+
+/**
+ * @brief This is a convenient type for working with a map containing pairs(string, pointer to a Blob instance).
+ */
+using BlobMap = std::map<std::string, Blob::Ptr>;
+
+/**
+ * @brief Represents real host memory allocated for a Tensor/Blob per C type.
+ */
+template<typename T,
+        typename = std::enable_if<std::is_pod<T>::value>>
+class TBlob : public Blob {
+    template<typename, typename> friend
+    class TBlob;
+
+
+public:
+    /**
+     * @brief Smart Pointer to this TBlob object.
+     */
+    using  Ptr = std::shared_ptr<TBlob<T>>;
+
+    /**
+     * @brief Creates a TBlob object with the specified dimensions and layout but does not allocate the memory.
+     * Please use the allocate() method to allocate memory.
+     * @param tensorDesc Tensor description
+     */
+    explicit TBlob(const TensorDesc& tensorDesc): Blob(tensorDesc) {}
+
+    /**
+     * @brief The constructor creates a TBlob object with the specified dimensions and layout
+     * on the pre-allocated memory. The allocate() call is not required.
+     * @param tensorDesc Tensor description
+     * @param ptr Pointer to the pre-allocated memory
+     * @param data_size Length of the pre-allocated array. If not set, size is assumed equal
+     * to the dot product of dims.
+     */
+    TBlob(const TensorDesc& tensorDesc, T* ptr, size_t data_sze = 0): Blob(tensorDesc) {
+        if (size() != 0 && ptr == nullptr) {
+            THROW_IE_EXCEPTION << "Using Blob on external nullptr memory";
+        }
+        _allocator = details::make_pre_allocator(ptr, size());
+        // blob on attached memory is always allocated, so we are not forcing the user to call allocate()
+        allocate();
+    }
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization.
+     */
+    explicit TBlob(Precision p, Layout l) : Blob(p, l) {}
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization.
+     * @brief Creates a TBlob object with the specified dimensions but does not allocate the memory. Please use the allocate() method to allocate memory.
+     * @param p Precision
+     * @param l Layout
+     * @param dims Tensor dimensions
+     */
+    TBlob(Precision p, Layout l, const SizeVector& dims)
+       : Blob(p, l, dims) {
+    }
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization.
+     * @brief The constructor creates a TBlob object with the specified dimensions on the pre-allocated memory. Therefore, the allocate() call is not required.
+     * @details The TBlob object doesn't own memory that is pointed to by the ptr. Therefore, it doesn't free the memory after the TBlob object is destroyed.
+     * Also certain operations might fail:
+     *  After the blob is constructed with this pointer its size is stored in the TBlob instance.
+     *  If the resize() operation happens which requires more memory, then the call to allocate() fails.
+     * @param p Precision
+     * @param dims Tensor dimensions
+     * @param ptr Pointer to the pre-allocated memory
+     * @param data_size Length of the pre-allocated array. If not set, size is assumed equal to dot product of dims.
+     */
+    TBlob(Precision p, Layout l, const SizeVector& dims, T* ptr, size_t data_sze = 0) : Blob(p, l, dims) {
+        if (size() != 0 && ptr == nullptr) {
+            THROW_IE_EXCEPTION << "Using Blob on external nullptr memory";
+        }
+        _allocator = details::make_pre_allocator(ptr, size());
+        // blob on attached memory is always allocated, so we are not forcing user to call allocate
+        allocate();
+    }
+
+    /**
+     * @deprecated Please use TensorDesc for Blob initialization.
+     * @brief Constructor. Creates a TBlob object with the specified precision, layout, dimensions and custom memory allocator.
+     * @param p Precision
+     * @param l Layout
+     * @param dims Tensor dimensions
+     * @param alloc Allocator to be used
+     */
+    TBlob(Precision p, Layout l, const SizeVector &dims, std::shared_ptr<IAllocator> alloc)
+            : Blob(p, l, dims), _allocator(alloc) {
+    }
+
+    /**
+     * @brief The copy constructor data is reallocated and copied from the source to the target blob.
+     * @param blob Source blob
+     */
+    TBlob(const TBlob<T> &blob) : Blob(blob.getTensorDesc()) {
+        copyFrom(blob);
+    }
+
+    /**
+     * @brief A move constructor.
+     * @param blob rvalue to make a move from
+     */
+    TBlob(TBlob<T> &&blob) : Blob(blob.getTensorDesc()) {
+        moveFrom(blob);
+    }
+
+    /**
+     * @brief Copy operator for the TBlob object.
+     * @param blob object reference to copy from
+     * @return Newly copied object
+     */
+    TBlob &operator=(const TBlob &blob) {
+        copyFrom(blob);
+        return *this;
+    }
+
+    /**
+     *@brief Virtual destructor.
+     */
+    virtual ~TBlob() {
+        free();
+    }
+
+    /**
+     * @brief Gets the size of the given type.
+     * @return Size of the type
+     */
+    size_t element_size() const noexcept override {
+        return sizeof(T);
+    }
+
+    /**
+     * @brief Creates an new empty rvalue LockedMemory object.
+     * @return rvalue for the empty locked object of type T
+     */
+    virtual LockedMemory<T> data() {
+        return std::move(lockme<T>());
+    }
+
+    /**
+     * @brief Creates a new empty rvalue read-only LockedMemory object.
+     * @return rvalue for the empty locked const object of type T.
+     */
+    virtual LockedMemory<const T> readOnly() const {
+        return std::move(lockme<const T>());
+    }
+
+    /**
+      * @deprecated Deprecated to avoid memcpy() calls.
+      * @brief Copies data from the given vector to the blob.
+      * @param that Vector of values to copy to the blob
+      */
+    void set(const std::vector<T> &that) {
+        if (tensorDesc.getDims().size() != 0 && that.size() != product(tensorDesc.getDims()))
+            THROW_IE_EXCEPTION << "Size mismatch between dims and vector";
+        if (tensorDesc.getDims().size() == 0) {
+            tensorDesc.setDims({static_cast<unsigned int>(that.size())});
+        }
+        allocate();
+        auto memptr = data();
+        memcpy(memptr, that.data(), product(tensorDesc.getDims()) * sizeof(T));
+    }
+
+    /**
+     * @brief Allocates or reallocates memory
+     */
+    void allocate() override {
+        if (_handle != nullptr) {
+            getAllocator()->free(_handle);
+        }
+        _handle = getAllocator()->alloc(TBlob<T>::product(tensorDesc.getDims()) * sizeof(T));
+    }
+
+    /**
+     * @brief Frees all allocated data
+     */
+    bool deallocate() override {
+        return free();
+    }
+
+    /**
+     * @brief Creates a new LockedMemory instance holding void pointer.
+     * @return LockedMemory instance holding void pointer
+     */
+    LockedMemory<void> buffer() override {
+        return std::move(lockme<void>());
+    }
+
+    /**
+     * @brief Creates a new LockedMemory instance holding constant void pointer.
+     * @return LockedMemory instance holding constant void pointer
+     */
+    LockedMemory<const void> cbuffer() const override {
+        return std::move(lockme<const void>());
+    }
+
+    /**
+     * @brief Gets BlobIterator for the data.
+     * Enables a ranged loop support for the TBlob object.
+     * @return BlobIterator object of type T
+     */
+    details::BlobIterator<T> begin() {
+        return details::BlobIterator<T>(data());
+    }
+
+    /**
+     * @brief Gets BlobIterator for the end of data.
+     * Enables a ranged loop support for the TBlob object.
+     * @return BlobIterator object of type T representing end of the data
+     */
+    details::BlobIterator<T> end() {
+        return details::BlobIterator<T>(data(), size());
+    }
+
+    /**
+     * @brief Gets a const BlobIterator for the read-only data.
+     * Enables a ranged loop support for the TBlob object.
+     * @return BlobIterator object of type const T
+     */
+    details::BlobIterator<const T> begin() const {
+        return details::BlobIterator<const T>(readOnly());
+    }
+
+    /**
+    * @brief Gets a const BlobIterator for the end of read-only data.
+    * Enables a ranged loop support for the TBlob object.
+    * @return BlobIterator object of type const T representing end of data
+    */
+    details::BlobIterator<const T> end() const {
+        return details::BlobIterator<const T>(readOnly(), size());
+    }
+
+
+protected:
+    /**
+     * @brief Local instance of IAllocator to manipulate memory.
+     */
+    mutable std::shared_ptr<IAllocator> _allocator;
+
+    /**
+     * @brief A handle for the stored memory returned from _allocator.alloc().
+     */
+    void *_handle = nullptr;
+
+    /**
+     * @brief Copies dimensions and data from the TBlob object.
+     * @param blob object reference to copy from
+     */
+    void copyFrom(const TBlob<T> &blob) {
+        tensorDesc = blob.tensorDesc;
+        this->allocate();
+        auto memptr = data();
+        memcpy(memptr, blob.readOnly(), product(tensorDesc.getDims()) * sizeof(T));
+    }
+
+    /**
+     * @brief Swaps memory handlers between the current blob and the given one.
+     * @tparam U Type of the blob to move from
+     * @param blob TBlob instance to move from
+     */
+    template<class U>
+    void moveFrom(TBlob<U> &blob) {
+        tensorDesc = blob.tensorDesc;
+        this->_allocator = std::move(blob._allocator);
+        std::swap(this->_handle, blob._handle);
+    }
+
+    /**
+     * @brief Frees handler and cleans up the stored data.
+     */
+    virtual bool free() {
+        bool bCanRelease = true;
+        if (_handle == nullptr) return bCanRelease;
+
+        bCanRelease = getAllocator()->free(_handle);
+        _handle = nullptr;
+        return bCanRelease;
+    }
+
+    /**
+     * @brief Creates a LockedMemory instance.
+     * @tparam S Type of the LockedMemory to be created
+     * @return A created instance of LockedMemory
+     */
+    template<class S>
+    LockedMemory<S> lockme() const {
+        return LockedMemory<S>(_allocator.get(), _handle, 0);
+    }
+
+    /**
+     * @brief Gets an allocator or creates a default one.
+     * @return IAllocator instance
+     */
+    const std::shared_ptr<IAllocator> &getAllocator() const noexcept override {
+        // in case when constructor without allocator was used
+        if (!_allocator) {
+            _allocator = shared_from_irelease(CreateDefaultAllocator());
+        }
+
+        return _allocator;
+    }
+
+    /**
+     * @brief Returns handle to the stored data.
+     */
+    void *getHandle() const noexcept override {
+        return _handle;
+    }
+};
+
+/**
+ * @deprecated Use TensorDesc to create Blob::Ptr.
+ * @brief Creates a blob with given precision and dimensions.
+ * @tparam Type Type of the shared pointer to be created
+ * @param p Given precision
+ * @param dims Given dimensions
+ * @return A shared pointer to the created blob
+ */
+template<class Type>
+inline typename TBlob<Type>::Ptr make_shared_blob(Precision p, Layout l, const SizeVector &dims) {
+    return std::make_shared<TBlob<Type>>(p, l, dims);
+}
+
+/**
+ * @deprecated Use TensorDesc to create Blob::Ptr
+ * @brief Creates a blob with the NCHW layout, given precision, and given dimensions.
+ * @tparam Type Type of the shared pointer to be created
+ * @param p Given precision
+ * @param dims Given dimensions
+ * @return A shared pointer to the created blob
+ */
+template<class Type>
+inline typename TBlob<Type>::Ptr make_shared_blob(Precision p, const SizeVector &dims) {
+    return make_shared_blob<Type>(p, TensorDesc::getLayoutByDims(dims), dims);
+}
+
+/**
+ * @deprecated Use TensorDesc to create Blob::Ptr
+ * @brief Creates a blob with the given precision.
+ * @tparam Type Type of the shared pointer to be created
+ * @param p Given precision
+ * @param arg Shared pointer to IAllocator to use in the blob
+ * @return A shared pointer to the blob created
+ */
+template<typename Type, class TArg>
+inline typename InferenceEngine::TBlob<Type>::Ptr make_shared_blob(Precision p, Layout l, const TArg &arg) {
+    return std::make_shared<InferenceEngine::TBlob<Type>>(p, l, arg);
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr
+ * @brief Creates a blob with the NCHW layout and given tensor precision.
+ * @tparam Type Type of the shared pointer to be created
+ * @param p Given precision
+ * @param arg Shared pointer to IAllocator to use in the blob
+ * @return A shared pointer to the blob created
+ */
+template<typename Type, class TArg>
+inline typename InferenceEngine::TBlob<Type>::Ptr make_shared_blob(Precision p, const TArg &arg) {
+    return make_shared_blob<Type, TArg>(p, TensorDesc::getLayoutByDims(arg), arg);
+}
+
+/**
+ * @brief Creates a blob with the given tensor descriptor.
+ * @tparam Type Type of the shared pointer to be created
+ * @param tensorDesc Tensor descriptor for Blob creation
+ * @return A shared pointer to the newly created blob of the given type
+ */
+template<typename Type>
+inline typename InferenceEngine::TBlob<Type>::Ptr make_shared_blob(const TensorDesc& tensorDesc) {
+    return std::make_shared<InferenceEngine::TBlob<Type>>(tensorDesc);
+}
+
+/**
+ * @brief Creates a blob with the given tensor descriptor from the pointer to the pre-allocated memory.
+ * @tparam Type Type of the shared pointer to be created
+ * @param tensorDesc TensorDesc for Blob creation
+ * @param ptr Pointer to the pre-allocated memory
+ * @param size Length of the pre-allocated array
+ * @return A shared pointer to the newly created blob of the given type
+ */
+template<typename Type>
+inline typename InferenceEngine::TBlob<Type>::Ptr make_shared_blob(const TensorDesc& tensorDesc, Type * ptr, size_t size = 0) {
+    return std::make_shared<InferenceEngine::TBlob<Type>>(tensorDesc, ptr, size);
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Gets a shared pointer for the new TBlob instance.
+ * The created instance is based on move semantics from the given TBlob instance.
+ * @tparam TypeTo Type of the shared pointer to be created
+ * @param arg rvalue for the blob to move from
+ * @return A shared pointer to the newly created blob of the given type
+ */
+template<typename TypeTo>
+inline typename InferenceEngine::TBlob<TypeTo>::Ptr make_shared_blob(TBlob<TypeTo> &&arg) {
+    return std::make_shared<InferenceEngine::TBlob<TypeTo>>(std::move(arg));
+}
+
+/**
+ * @brief Creates a copy of given TBlob instance.
+ * @tparam TypeTo Type of the shared pointer to be created
+ * @param arg given pointer to blob
+ * @return A shared pointer to the newly created blob of the given type
+ */
+template<typename TypeTo>
+inline typename InferenceEngine::TBlob<TypeTo>::Ptr make_shared_blob(const TBlob<TypeTo> &arg) {
+    return std::make_shared<InferenceEngine::TBlob<TypeTo>>(arg);
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the given precision.
+ * @tparam Type Type of the shared pointer to be created
+ * @param p Given precision
+ * @return A shared pointer to the blob created
+ */
+template<typename Type>
+inline typename InferenceEngine::TBlob<Type>::Ptr make_shared_blob(Precision p, Layout l = NCHW) {
+    return std::make_shared<TBlob<Type>>(p, l);
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the given precision, layout and dimensions from the vector of values.
+ * @tparam TypeTo Type of the shared pointer to be created
+ * @param p Given precision
+ * @param l Given Layout
+ * @param dims Given dimensions
+ * @param arg Vector of values
+ * @return A shared pointer to the blob created
+ */
+template<typename TypeTo>
+inline typename TBlob<TypeTo>::Ptr make_shared_blob(Precision p, Layout l, SizeVector dims, const std::vector<TypeTo> &arg) {
+    auto blob = std::make_shared<TBlob<TypeTo>>(p, l, dims);
+    blob->set(arg);
+    return blob;
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the given precision from the vector of values.
+ * @tparam TypeTo Type of the shared pointer to be created
+ * @param p Given precision
+ * @param l Layout
+ * @param arg Vector of values
+ * @return A shared pointer to the blob created
+ */
+template<typename TypeTo>
+inline typename TBlob<TypeTo>::Ptr make_shared_blob(Precision p, Layout l, const std::vector<TypeTo> &arg) {
+    auto blob = std::make_shared<TBlob<TypeTo>>(p, l);
+    blob->set(arg);
+    return blob;
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the NCHW layout and the given precision from the vector of values.
+ * @tparam TypeTo Type of the shared pointer to be created
+ * @param p Given precision
+ * @param arg Vector of values
+ * @return A shared pointer to the blob created
+ */
+template<typename TypeTo>
+inline typename TBlob<TypeTo>::Ptr make_shared_blob(Precision p, const std::vector<TypeTo> &arg) {
+    return make_shared_blob<TypeTo>(p, TensorDesc::getLayoutByDims(arg), arg);
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the given precision from the pointer to the pre-allocated memory.
+ * @param p Given precision
+ * @param l Layout
+ * @param dims Given dimensions
+ * @param ptr Pointer to the pre-allocated memory
+ * @param size Length of the pre-allocated array
+ * @return A shared pointer to the blob created
+ */
+template <typename TypeTo>
+inline typename TBlob<TypeTo>::Ptr make_shared_blob(Precision p, Layout l, const SizeVector &dims, TypeTo * ptr, size_t size = 0) {
+    auto blob = std::make_shared<TBlob<TypeTo>>(p, l, dims, ptr, size);
+    return blob;
+}
+
+/**
+ * @deprecated Use TensorDesc in order to create Blob::Ptr.
+ * @brief Creates a blob with the NCHW layout and the given precision from the pointer to the pre-allocated memory
+ * @param p Given precision
+ * @param dims Given dimensions
+ * @param ptr Pointer to the pre-allocated memory
+ * @param size Length of the pre-allocated array
+ * @return A shared pointer to the blob created
+ */
+template <typename TypeTo>
+inline typename TBlob<TypeTo>::Ptr make_shared_blob(Precision p, const SizeVector &dims, TypeTo * ptr, size_t size = 0) {
+    return make_shared_blob<TypeTo>(p, TensorDesc::getLayoutByDims(dims), dims, ptr, size);
+}
+
+/**
+ * @brief This structure describes ROI data.
+ */
+struct ROI {
+    size_t id;     // ID of a ROI
+    size_t posX;   // W upper left coordinate of ROI
+    size_t posY;   // H upper left coordinate of ROI
+    size_t sizeX;  // W size of ROI
+    size_t sizeY;  // H size of ROI
+};
+
+/**
+ * @brief Creates a blob describing given ROI object based on the given blob with pre-allocated memory.
+ * @param inputBlob original blob with pre-allocated memory.
+ * @param roi A ROI object inside of the original blob.
+ * @return A shared pointer to the newly created blob.
+ */
+INFERENCE_ENGINE_API_CPP(Blob::Ptr) make_shared_blob(const Blob::Ptr &inputBlob, const ROI &roi);
+
+}  // namespace InferenceEngine

inference-engine/include/ie_common.h

@@ -0,0 +1,223 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file with common inference engine definitions.
+ * @file ie_common.h
+ */
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <string>
+#include <ostream>
+#include <algorithm>
+#include <details/ie_exception.hpp>
+
+namespace InferenceEngine {
+/**
+ * @brief Represents tensor size.
+ * The order is opposite to the order in Caffe*: (w,h,n,b) where the most frequently changing element in memory is first.
+ */
+using SizeVector = std::vector<size_t>;
+
+/**
+ * @brief This class represents the generic layer.
+ */
+class CNNLayer;
+
+/**
+ * @brief A smart pointer to the CNNLayer
+ */
+using CNNLayerPtr = std::shared_ptr<CNNLayer>;
+/**
+ * @brief A smart weak pointer to the CNNLayer
+ */
+using  CNNLayerWeakPtr = std::weak_ptr<CNNLayer>;
+
+/**
+ * @brief The main data representation node
+ */
+class Data;
+
+/**
+ * @brief Smart pointer to Data
+ */
+using DataPtr = std::shared_ptr<Data>;
+
+/**
+ * @brief Smart pointer to constant Data
+ */
+using CDataPtr = std::shared_ptr<const Data>;
+
+/**
+ * @brief Smart weak pointer to Data
+ */
+using DataWeakPtr = std::weak_ptr<Data>;
+
+/**
+ * @union UserValue
+ * @brief The method holds the user values to enable binding of data per graph node.
+ */
+union UserValue {
+    int v_int;
+    float v_float;
+    void *v_ptr;
+};
+
+/**
+ * @enum Layout
+ * @brief Layouts that the inference engine supports
+ */
+enum Layout : uint8_t {
+    ANY = 0,           // "any" layout
+
+    // I/O data layouts
+    NCHW = 1,
+    NHWC = 2,
+
+    // weight layouts
+    OIHW = 64,
+
+    // bias layouts
+    C = 96,
+
+    // Single image layout (for mean image)
+    CHW = 128,
+
+    // 2D
+    HW = 192,
+    NC = 193,
+    CN = 194,
+
+    BLOCKED = 200,
+};
+
+/**
+ * @struct InferenceEngineProfileInfo
+ * @brief Represents basic inference profiling information per layer.
+ * If the layer is executed using tiling, the sum time per each tile is indicated as the total execution time.
+ * Due to parallel execution, the total execution time for all layers might be greater than the total inference time.
+ */
+struct InferenceEngineProfileInfo {
+    /**
+     * @brief Defines the general status of the layer
+     */
+    enum LayerStatus {
+        NOT_RUN,
+        OPTIMIZED_OUT,
+        EXECUTED
+    };
+
+    LayerStatus status;
+    /**
+     * @brief The absolute time in microseconds that the layer ran (in total)
+     */
+    long long realTime_uSec;
+    /**
+     * @brief The net host cpu time that the layer ran
+     */
+    long long cpu_uSec;
+
+    /**
+     * @brief An execution type of unit
+     */
+    char exec_type[256] = {};
+
+    /**
+     * @brief A layer type
+     */
+    char layer_type[256] = {};
+
+    /**
+     * @brief An execution index of the unit
+     */
+    unsigned execution_index;
+};
+
+
+/**
+ * @enum StatusCode
+ * @brief This enum contains codes for all possible return values of the interface functions
+ */
+enum StatusCode : int {
+    OK = 0,
+    GENERAL_ERROR = -1,
+    NOT_IMPLEMENTED = -2,
+    NETWORK_NOT_LOADED = -3,
+    PARAMETER_MISMATCH = -4,
+    NOT_FOUND = -5,
+    OUT_OF_BOUNDS = -6,
+    /*
+     * @brief exception not of std::exception derived type was thrown
+     */
+    UNEXPECTED = -7,
+    REQUEST_BUSY = -8,
+    RESULT_NOT_READY = -9,
+    NOT_ALLOCATED = -10,
+    INFER_NOT_STARTED = -11
+};
+
+/**
+ * @struct ResponseDesc
+ * @brief  Represents detailed information for an error
+ */
+struct ResponseDesc {
+    /**
+     * @brief A character buffer that holds the detailed information for an error.
+     */
+    char msg[256] = {};
+};
+
+/** @brief This class represents StatusCode::GENERIC_ERROR exception */
+class GeneralError : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::NOT_IMPLEMENTED exception */
+class NotImplemented : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::NETWORK_NOT_LOADED exception */
+class NetworkNotLoaded : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::PARAMETER_MISMATCH exception */
+class ParameterMismatch : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::NOT_FOUND exception */
+class NotFound : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::OUT_OF_BOUNDS exception */
+class OutOfBounds : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::UNEXPECTED exception */
+class Unexpected : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::REQUEST_BUSY exception */
+class RequestBusy : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::RESULT_NOT_READY exception */
+class ResultNotReady : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::NOT_ALLOCATED exception */
+class NotAllocated : public std::logic_error
+{ using std::logic_error::logic_error; };
+
+/** @brief This class represents StatusCode::INFER_NOT_STARTED exception */
+class InferNotStarted : public std::logic_error
+{ using std::logic_error::logic_error; };
+}  // namespace InferenceEngine
+
+#if defined(_WIN32)
+    #define __PRETTY_FUNCTION__ __FUNCSIG__
+#else
+    #define __PRETTY_FUNCTION__ __PRETTY_FUNCTION__
+#endif

inference-engine/include/ie_data.h

@@ -0,0 +1,165 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This header file defines the main Data representation node.
+ * @file ie_data.h
+ */
+#pragma once
+
+#include <map>
+#include <memory>
+#include <vector>
+#include "ie_api.h"
+#include "ie_common.h"
+#include "details/ie_exception.hpp"
+#include "ie_precision.hpp"
+#include "ie_layouts.h"
+#include <string>
+
+namespace InferenceEngine {
+/**
+ * @brief This class represents the main Data representation node.
+ *
+ * The NN graphs are di-graphs consisting of data nodes and layer nodes.
+ */
+class INFERENCE_ENGINE_API_CLASS(Data) {
+public:
+    /**
+     * @deprecated Deprecated. Please use getPrecision()
+     * @brief A precision type of this Data instance
+     */
+    Precision precision;
+    /**
+     * @deprecated Deprecated. Please use getFormat()
+     * @brief A data layout of this Data instance
+     */
+    Layout layout;
+    /**
+     * @deprecated Deprecated. Please use getDims()
+     * @brief A tensor dimension array (the order is opposite to the order in the IR: w,h,c,n) of this Data instance
+     */
+    SizeVector dims;
+    /**
+     * @deprecated Deprecated. Please use getCreatorLayer()
+     * @brief A pointer to the layer that creates this data element, null for input data elements
+     */
+    CNNLayerWeakPtr creatorLayer;
+    /**
+     * @deprecated Deprecated. Please use getName()
+     * @brief A unique name that identifies this data node
+     */
+    std::string name;
+    /**
+     * @deprecated Deprecated. Please use getInputTo()
+     * @brief A map of layers that use this node as input.
+     * It is useful for recursive NN graph traversal.
+     */
+    std::map<std::string, CNNLayerPtr> inputTo;
+    /**
+     * @deprecated Deprecated. Please use getUserObject()
+     * @brief A user utility place holder
+     */
+    UserValue userObject;
+
+    /**
+     * @brief An empty constructor (dimensionless)
+     * @param name Name of the data node
+     * @param _precision Precision of the data
+     */
+    Data(const std::string &name, Precision _precision, Layout layout = NCHW);
+
+    /**
+     * @brief A full constructor (with dimensions)
+     * @param name Name of the data node
+     * @param a_dims Data tensor dimensions
+     * @param _precision Precision of the data
+     */
+    Data(const std::string &name, const SizeVector &a_dims, Precision _precision, Layout layout = NCHW);
+    /**
+     * @brief A constructor with tensor descriptor
+     * @param name Name of the data node
+     * @param desc Tensor descriptor
+     */
+    Data(const std::string &name, const TensorDesc& desc);
+
+    /**
+     * @brief Checks if the current node is resolved
+     * @return true if resolved, false otherwise.
+     */
+    bool isInitialized() const;
+
+    /**
+     * @brief Sets the data dimensions.
+     * After the current node is marked as resolved.
+     * @param a_dims Tensor dimensions to set
+     */
+    void setDims(const SizeVector &a_dims);
+
+    /**
+    * @deprecated
+    * @brief Sets the batch value in the data dimensions.
+    * Batch is defined as the last element in the dimensions vector.
+    * @param batch_size Batch size to set
+    */
+    inline void setBatchSize(size_t batch_size);
+
+    /**
+    * @brief Sets the layout value for this Data instance
+    * @param layout Layout value to set
+    */
+    void setLayout(Layout layout);
+
+    /**
+    * @brief Gets the layout value for this Data instance
+    */
+    Layout getLayout() const;
+
+    /**
+    * @brief Gets Tensor descriptor reference
+      @return reference to TensorDesc
+    */
+    const TensorDesc& getTensorDesc() const;
+
+    /**
+     * @brief Gets a precision type of this Data instance
+     * @return Precision type
+     */
+    const Precision& getPrecision() const;
+
+    /**
+     * @brief Gets a precision type of this Data instance
+     * @return Precision type
+     */
+    void setPrecision(const Precision& precision);
+
+    /**
+     * @return data dimensions
+     */
+    const SizeVector& getDims() const;
+
+    /**
+     * @return owner of this data layer, parent layer in di-graph
+     */
+    CNNLayerWeakPtr& getCreatorLayer();
+
+    /**
+     * @return name of the data object
+     */
+    const std::string& getName() const;
+
+    /**
+     * @brief returns child layers in di-graph
+     */
+    std::map<std::string, CNNLayerPtr>& getInputTo();
+
+    /**
+     * @return convenient arbitrary user data holder
+     */
+    const UserValue& getUserObject() const;
+private:
+    TensorDesc tensorDesc;
+};
+}  // namespace InferenceEngine

inference-engine/include/ie_device.hpp

@@ -0,0 +1,129 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This header file contains aspects of working on different devices like CPU, GEN, FPGA, etc.
+ * @file ie_device.hpp
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include <map>
+#include <ie_api.h>
+#include <ie_common.h>
+
+namespace InferenceEngine {
+
+/**
+ * @enum TargetDevice
+ * @brief Describes known device types
+ */
+enum class TargetDevice : uint8_t {
+    eDefault = 0,
+    eBalanced = 1,
+    eCPU = 2,
+    eGPU = 3,
+    eFPGA = 4,
+    eMYRIAD = 5,
+    eGNA = 7,
+    eHETERO = 8
+};
+
+/**
+ * @brief Describes the relationship between the enumerator type and the actual device's name
+ */
+class TargetDeviceInfo {
+    struct Info {
+        TargetDevice device;
+        std::string name;
+        Info(TargetDevice device, std::string name) : device(device), name(name){}
+    };
+    static const std::vector<Info> & getAll() {
+#define DECL_DEVICE(device_type) {TargetDevice::e##device_type, #device_type}
+
+        static std::vector<Info> g_allDeviceInfos = {
+            DECL_DEVICE(Default),
+            DECL_DEVICE(Balanced),
+            DECL_DEVICE(CPU),
+            DECL_DEVICE(GPU),
+            DECL_DEVICE(FPGA),
+            DECL_DEVICE(MYRIAD),
+            DECL_DEVICE(GNA),
+            DECL_DEVICE(HETERO)
+        };
+#undef DECLARE
+        return g_allDeviceInfos;
+    }
+
+ public:
+    static TargetDevice fromStr(const std::string &deviceName) {
+        static std::map<std::string, InferenceEngine::TargetDevice> deviceFromNameMap = {
+            { "CPU", InferenceEngine::TargetDevice::eCPU },
+            { "GPU", InferenceEngine::TargetDevice::eGPU },
+            { "FPGA", InferenceEngine::TargetDevice::eFPGA },
+            { "MYRIAD", InferenceEngine::TargetDevice::eMYRIAD },
+            { "GNA", InferenceEngine::TargetDevice::eGNA },
+            { "BALANCED", InferenceEngine::TargetDevice::eBalanced },
+            { "HETERO", InferenceEngine::TargetDevice::eHETERO }
+        };
+        auto val = deviceFromNameMap.find(deviceName);
+        return val != deviceFromNameMap.end() ? val->second : InferenceEngine::TargetDevice::eDefault;
+    }
+
+    static const char * name(TargetDevice device) {
+        auto res = std::find_if(getAll().cbegin(), getAll().cend(), [&](const Info & info){
+            return device == info.device;
+        });
+        if (res == getAll().cend()) {
+            return "Unknown device";
+        }
+        return res->name.c_str();
+    }
+};
+
+/**
+ * @brief Returns the device name
+ * @param device Instance of TargetDevice
+ * @return A c-string with the name
+ */
+inline const char *getDeviceName(TargetDevice device) {
+    return TargetDeviceInfo::name(device);
+}
+
+/**
+ * @struct FindPluginRequest
+ * @brief Defines a message that contains the TargetDevice object to find a plugin for
+ */
+struct FindPluginRequest {
+    /**
+     * @brief object of TargetDevice to find a plugin for
+     */
+    TargetDevice device;
+};
+
+/**
+ * @struct FindPluginResponse
+ * @brief Defines a message that contains a list of appropriate plugin names
+ */
+struct FindPluginResponse {
+    /**
+     * @brief A list of appropriate plugin names
+     */
+    std::vector<std::string> names;
+};
+
+/**
+ * @brief Finds an appropriate plugin for requested target device
+ * @param req A requested target device
+ * @param result The results of the request
+ * @param resp The response message description
+ * @return A response message
+ */
+FindPluginResponse findPlugin(const FindPluginRequest &req);
+
+INFERENCE_ENGINE_API(StatusCode) findPlugin(const FindPluginRequest &req, FindPluginResponse &result,
+                                            ResponseDesc *resp) noexcept;
+}  // namespace InferenceEngine

inference-engine/include/ie_error.hpp

@@ -0,0 +1,25 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for a plugin logging mechanism
+ * @file ie_error.hpp
+ */
+#pragma once
+
+namespace InferenceEngine {
+/**
+ * @brief This class represents a custom error listener.
+ * Plugin consumers can provide it via InferenceEngine::SetLogCallback
+ */
+class IErrorListener {
+public:
+    /**
+     * @brief The plugin calls this method with a null terminated error message (in case of error)
+     * @param msg Error message
+     */
+    virtual void onError(const char *msg) noexcept = 0;
+};
+}  // namespace InferenceEngine

inference-engine/include/ie_extension.h

@@ -0,0 +1,214 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that defines a wrapper class for handling extension instantiation and releasing resources
+ * @file ie_extension.h
+ */
+#pragma once
+
+#include "details/ie_so_pointer.hpp"
+#include "ie_iextension.h"
+#include "mkldnn/mkldnn_extension_ptr.hpp"
+#include <string>
+#include <memory>
+#include <map>
+
+namespace InferenceEngine {
+namespace details {
+
+/**
+ * @brief The SOCreatorTrait class specialization for IExtension case, defines the name of the fabric method for creating IExtension object in DLL
+ */
+template<>
+class SOCreatorTrait<IExtension> {
+public:
+    /**
+     * @brief A name of the fabric method for creating an IExtension object in DLL
+     */
+    static constexpr auto name = "CreateExtension";
+};
+
+/**
+ * @brief The SOCreatorTrait class specialization for IExtension case, defines the name of the fabric method for creating IExtension object in DLL
+ */
+template<>
+class SOCreatorTrait<IShapeInferExtension> {
+public:
+    /**
+     * @brief A name of the fabric method for creating an IShapeInferExtension object in DLL
+     */
+    static constexpr auto name = "CreateShapeInferExtension";
+};
+
+}  // namespace details
+
+/**
+ * @brief This class is a C++ helper to work with objects created using extensions.
+ */
+class Extension : public IExtension {
+public:
+    /**
+   * @brief Loads extension from a shared library
+   * @param name Full or relative path to extension library
+   */
+    explicit Extension(const std::string &name)
+            : actual(name) {}
+
+    /**
+     * @brief Gets the extension version information
+     * @param versionInfo A pointer to version info, set by the plugin
+     */
+    void GetVersion(const InferenceEngine::Version *&versionInfo) const noexcept override {
+        actual->GetVersion(versionInfo);
+    }
+
+    /**
+     * @brief Sets a log callback that is used to track what is going on inside
+     * @param listener Logging listener
+     */
+    void SetLogCallback(InferenceEngine::IErrorListener &listener) noexcept override {
+        actual->SetLogCallback(listener);
+    }
+
+    /**
+     * @brief Cleans the resources up
+     */
+    void Unload() noexcept override {
+        actual->Unload();
+    }
+
+    /**
+     * @brief Does nothing since destruction is done via the regular mechanism
+     */
+    void Release() noexcept override {}
+
+    /**
+     * @brief Gets the array with types of layers which are included in the extension
+     * @param types Types array
+     * @param size Size of the types array
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    StatusCode getPrimitiveTypes(char**& types, unsigned int& size, ResponseDesc* resp) noexcept override {
+        return actual->getPrimitiveTypes(types, size, resp);
+    }
+
+    /**
+     * @brief Gets the factory with implementations for a given layer
+     * @param factory Factory with implementations
+     * @param cnnLayer A layer to get the factory for
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    StatusCode getFactoryFor(ILayerImplFactory *&factory, const CNNLayer *cnnLayer,
+                                     ResponseDesc *resp) noexcept override {
+        return actual->getFactoryFor(factory, cnnLayer, resp);
+    }
+
+    StatusCode getShapeInferImpl(IShapeInferImpl::Ptr& impl, const char* type, ResponseDesc* resp) noexcept override {
+        return actual->getShapeInferImpl(impl, type, resp);
+    }
+
+protected:
+    /**
+    * @brief A SOPointer instance to the loaded templated object
+    */
+    InferenceEngine::details::SOPointer<IExtension> actual;
+};
+
+/**
+ * @brief This class is a C++ helper to work with objects created using extensions.
+ */
+class ShapeInferExtension : public IShapeInferExtension {
+public:
+    /**
+   * @brief Loads extension from a shared library
+   * @param name Full or relative path to extension library
+   */
+    explicit ShapeInferExtension(const std::string &name)
+            : actual(name) {}
+
+    /**
+     * @brief Gets the extension version information
+     * @param versionInfo A pointer to version info, set by the plugin
+     */
+    void GetVersion(const InferenceEngine::Version *&versionInfo) const noexcept override {
+        actual->GetVersion(versionInfo);
+    }
+
+    /**
+     * @brief Sets a log callback that is used to track what is going on inside
+     * @param listener Logging listener
+     */
+    void SetLogCallback(InferenceEngine::IErrorListener &listener) noexcept override {
+        actual->SetLogCallback(listener);
+    }
+
+    /**
+     * @brief Cleans the resources up
+     */
+    void Unload() noexcept override {
+        actual->Unload();
+    }
+
+    /**
+     * @brief Does nothing since destruction is done via the regular mechanism
+     */
+    void Release() noexcept override {}
+
+    /**
+     * @brief Gets the array with types of layers which are included in the extension
+     * @param types Types array
+     * @param size Size of the types array
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    StatusCode getPrimitiveTypes(char**& types, unsigned int& size, ResponseDesc* resp) noexcept override {
+        return actual->getPrimitiveTypes(types, size, resp);
+    }
+
+    /**
+     * @brief Gets shape propagation implementation for the given string-type of cnn Layer
+     * @param impl the vector with implementations which is ordered by priority
+     * @param resp response descriptor
+     * @return status code
+     */
+    StatusCode getShapeInferImpl(IShapeInferImpl::Ptr& impl, const char* type, ResponseDesc* resp) noexcept override {
+        return actual->getShapeInferImpl(impl, type, resp);
+    }
+
+protected:
+    /**
+    * @brief A SOPointer instance to the loaded templated object
+    */
+    InferenceEngine::details::SOPointer<IShapeInferExtension> actual;
+};
+
+/**
+ * @brief Creates a special shared_pointer wrapper for the given type from a specific shared module
+ * @param name Name of the shared library file
+ * @return shared_pointer A wrapper for the given type from a specific shared module
+ */
+template<>
+inline std::shared_ptr<IShapeInferExtension> make_so_pointer(const std::string &name) {
+    return std::make_shared<ShapeInferExtension>(name);
+}
+
+/**
+ * @brief Creates a special shared_pointer wrapper for the given type from a specific shared module
+ * @param name Name of the shared library file
+ * @return shared_pointer A wrapper for the given type from a specific shared module
+ */
+template<>
+inline std::shared_ptr<IExtension> make_so_pointer(const std::string &name) {
+    try {
+        return std::make_shared<Extension>(name);
+    } catch (InferenceEngine::details::InferenceEngineException& ex) {
+        return std::make_shared<MKLDNNPlugin::MKLDNNExtension>(name);
+    }
+}
+
+}  // namespace InferenceEngine

inference-engine/include/ie_icnn_net_reader.h

@@ -0,0 +1,108 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides interface for network reader that is used to build networks from a given IR
+ * @file ie_icnn_net_reader.h
+ */
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "ie_blob.h"
+#include "ie_common.h"
+#include "ie_icnn_network.hpp"
+#include "details/ie_no_copy.hpp"
+#include "ie_api.h"
+
+namespace InferenceEngine {
+/**
+ * @brief This class is the main interface to build and parse a network from a given IR
+ *
+ * All methods here do not throw exceptions and return a StatusCode and ResponseDesc object.
+ * Alternatively, to use methods that throw exceptions, refer to the CNNNetReader wrapper class.
+ */
+class ICNNNetReader : public details::IRelease {
+public:
+    /**
+     * @brief Parses the topology part of the IR (.xml)
+     * @param filepath The full path to the .xml file of the IR
+     * @param resp Response message
+     * @return Result code
+     */
+    virtual StatusCode ReadNetwork(const char *filepath, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Parses the topology part of the IR (.xml) given the xml as a buffer
+     * @param model Pointer to a char array with the IR
+     * @param resp Response message
+     * @param size Size of the char array in bytes
+     * @return Result code
+     */
+    virtual StatusCode ReadNetwork(const void *model, size_t size, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Sets the weights buffer (.bin part) from the IR.
+     * Weights Blob must always be of bytes - the casting to precision is done per-layer to support mixed
+     * networks and to ease of use.
+     * This method can be called more than once to reflect updates in the .bin.
+     * @param weights Blob of bytes that holds all the IR binary data
+     * @param resp Response message
+     * @return Result code
+    */
+    virtual StatusCode SetWeights(const TBlob<uint8_t>::Ptr &weights, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Loads and sets the weights buffer directly from the IR .bin file.
+     * This method can be called more than once to reflect updates in the .bin.
+     * @param filepath Full path to the .bin file
+     * @param resp Response message
+     * @return Result code
+     */
+    virtual StatusCode ReadWeights(const char *filepath, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Returns a pointer to the built network
+     * @param resp Response message
+     */
+    virtual ICNNNetwork *getNetwork(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Retrieves the last building status
+     * @param resp Response message
+     */
+    virtual bool isParseSuccess(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Retrieves the last building failure message if failed
+     * @param resp Response message
+     * @return StatusCode that indicates the network status
+     */
+    virtual StatusCode getDescription(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Gets network name
+     * @param name Pointer to preallocated buffer that receives network name
+     * @param len Length of the preallocated buffer, network name will be trimmed by this lenght
+     * @param resp Response message
+     * @return Result code
+     */
+    virtual StatusCode getName(char *name, size_t len, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Returns a version of IR
+     * @param resp Response message
+     * @return IR version number: 1 or 2
+     */
+    virtual int getVersion(ResponseDesc *resp) noexcept = 0;
+};
+
+/**
+ * @brief Creates a CNNNetReader instance
+ * @return An object that implements the ICNNNetReader interface
+ */
+INFERENCE_ENGINE_API(ICNNNetReader*)CreateCNNNetReader() noexcept;
+}  // namespace InferenceEngine

inference-engine/include/ie_icnn_network.hpp

@@ -0,0 +1,181 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file for the ICNNNetwork class
+ * @file ie_icnn_network.hpp
+ */
+#pragma once
+
+#include "ie_common.h"
+#include "ie_layers.h"
+#include "ie_data.h"
+#include "ie_device.hpp"
+#include "ie_blob.h"
+#include "details/ie_irelease.hpp"
+#include "ie_preprocess.hpp"
+#include "ie_input_info.hpp"
+#include "ie_iextension.h"
+#include <memory>
+#include <map>
+#include <string>
+
+namespace InferenceEngine {
+
+/**
+ * @brief A collection that contains string as key, and Data smart pointer as value
+ */
+using OutputsDataMap = std::map<std::string, DataPtr>;
+
+/**
+ * @brief This is the main interface to describe the NN topology
+ */
+class ICNNNetwork : public details::IRelease {
+public:
+    /**
+     * @brief Returns the main network operating precision.
+     * This may be MIXED if not homogeneous.
+     * @return A precision type
+     */
+    virtual Precision getPrecision() const noexcept = 0;
+
+    /**
+     * @brief Gets the network output Data node information. The received info is stored in the given Data node.
+     * For single and multiple outputs networks.
+     * @param out Reference to the OutputsDataMap object
+     */
+    virtual void getOutputsInfo(OutputsDataMap& out) const noexcept  = 0;
+
+    /**
+     * @brief Gets the network input Data node information. The received info is stored in the given InputsDataMap object.
+     * For single and multiple inputs networks.
+     * This method must be called to find out input names for using them later during filling of a map
+     * of blobs passed later to InferenceEngine::IInferencePlugin::Infer()
+     * @param inputs Reference to InputsDataMap object.
+     */
+    virtual void getInputsInfo(InputsDataMap& inputs) const noexcept  = 0;
+
+
+    /**
+     * @brief Returns information on certain input pointed by inputName
+     * @param inputName Name of input layer to get info on
+     * @return A smart pointer to the input information
+     */
+    virtual InputInfo::Ptr getInput(const std::string& inputName) const noexcept = 0;
+
+    /**
+     * @brief Gets the network name. The name is stored in the given pName string.
+     * @param pName - will receive actual network name, specified in IR file,
+     *     pName should point to valid memory address before invoking this function
+     * @param len - size in bytes of pName buffer, actual name is trimmed by this size
+     */
+    virtual void getName(char* pName, size_t len) const noexcept = 0;
+
+    /**
+     * @brief Returns the network name.
+     * @return Network name
+     */
+    virtual const std::string& getName() const noexcept = 0;
+
+    /**
+    * @brief Returns the number of layers in the network as an integer value
+    * @return The number of layers as an integer value
+    */
+    virtual size_t layerCount() const noexcept = 0;
+
+    /**
+    * @brief Returns a smart pointer reference to a Data node given its name.
+     * If the Data node is missing, returns reference to a default initialized new empty data pointer with given name.
+    * @param dname Name of the Data node
+    * @return Data node smart pointer
+    */
+    virtual DataPtr& getData(const char* dname)  noexcept = 0;
+
+    /**
+    * @brief Insert a layer into the network. A user is responsible to connect it to other data elements.
+    * @param layer Const reference to a layer smart pointer
+    */
+    virtual void addLayer(const CNNLayerPtr& layer) noexcept = 0;
+
+    /**
+     * @brief Adds output to the layer
+     * @param layerName Name of the layer
+     * @param outputIndex Index of the output
+     * @param resp Response message
+     * @return Status code of the operation
+     */
+    virtual StatusCode
+    addOutput(const std::string& layerName, size_t outputIndex = 0, ResponseDesc* resp = nullptr) noexcept = 0;
+
+    /**
+     * @brief Gets network layer with the given name
+     * @param layerName Given name of the layer
+     * @param out Pointer to the found CNNLayer object with the given name
+     * @param resp Pointer to the response message that holds a description of an error if any occurred
+     * @return Status code of the operation. OK if succeeded
+     */
+    virtual StatusCode getLayerByName(const char* layerName, CNNLayerPtr& out, ResponseDesc* resp) const noexcept = 0;
+
+    /**
+     * @brief Sets a desirable device to perform all work on.
+     * Some plug-ins might not support some target devices and may abort execution with an appropriate error message.
+     * @param device Device to set as a target
+     */
+    virtual void setTargetDevice(TargetDevice device) noexcept = 0;
+
+    /**
+     * @brief Gets the target device.
+     * If setTargetDevice() was not called before, returns eDefault
+     * @return A TargetDevice instance
+     */
+    virtual TargetDevice getTargetDevice() const noexcept = 0;
+
+    /**
+     * @deprecated use setBatchSize with ResponseDesc to get error message
+     * @brief Changes the inference batch size
+     */
+    virtual StatusCode setBatchSize(const size_t size) noexcept = 0;
+
+    /**
+     * @brief Changes the inference batch size.
+     * @note There are several limitations and it's not recommended to use it. Set batch to the input shape and call @reshape.
+     * @param size Size of batch to set
+     * @return Status code of the operation
+     * @note: Current implementation of the function sets batch size to the first dimension of 4D input layers in the networks
+     * and starts shape inference for IR starting from v3, for IR v2 it sets batch to the first dimension for all layers.
+     * Custom layers might require custom shape infer implementation, use @IShapeInferExtension interface to register them.
+     */
+    virtual StatusCode setBatchSize(size_t size, ResponseDesc* responseDesc) noexcept = 0;
+
+    /**
+    * @brief Gets the inference batch size
+    * @return The size of batch as a size_t value
+    */
+    virtual size_t getBatchSize() const noexcept = 0;
+
+    /**
+     * @brief Map of pairs: name of corresponding data and its dimension.
+     */
+    using InputShapes = std::map<std::string, SizeVector>;
+
+    /**
+    * @brief - Run shape inference with new input shapes for the network
+    * @param inputShapes - map of pairs: name of corresponding data and its dimension.
+     * @note currently all inputs are required
+    * @param resp Pointer to the response message that holds a description of an error if any occurred
+    * @return Status code of the operation
+    */
+    virtual StatusCode reshape(const InputShapes& inputShapes, ResponseDesc* resp) noexcept { return NOT_IMPLEMENTED; };
+
+    /**
+     * @brief Registers extension within the plugin
+     * @param extension Pointer to already loaded reader extension with shape propagation implementations
+     * @param resp Pointer to the response message that holds a description of an error if any occurred
+     * @return Status code of the operation. OK if succeeded
+     */
+    virtual StatusCode
+    AddExtension(const IShapeInferExtensionPtr& extension, ResponseDesc* resp) noexcept { return NOT_IMPLEMENTED; };
+};
+}  // namespace InferenceEngine

inference-engine/include/ie_icnn_network_stats.hpp

@@ -0,0 +1,56 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file for the ICNNNetworkStats class
+ * @file ie_icnn_network_stats.hpp
+ */
+#pragma once
+
+#include <string>
+#include <memory>
+#include <limits>
+#include <vector>
+
+namespace InferenceEngine {
+
+/**
+ * @class ICNNNetworkStats
+ * @brief This is the interface to describe the NN topology scoring statistics
+ */
+class ICNNNetworkStats : public details::IRelease {
+public:
+    virtual void SaveToFile(const std::string& xmlPath, const std::string& binPath) const = 0;
+    virtual void LoadFromFile(const std::string& xmlPath, const std::string& binPath) = 0;
+
+    virtual bool isEmpty() const = 0;
+};
+
+
+class NetworkNodeStats;
+
+using NetworkNodeStatsPtr = std::shared_ptr<NetworkNodeStats>;
+using NetworkNodeStatsWeakPtr = std::weak_ptr<NetworkNodeStats>;
+
+class NetworkNodeStats {
+public:
+    NetworkNodeStats() { }
+    explicit NetworkNodeStats(int statCount) {
+        float min = std::numeric_limits<float>::max();
+        float max = std::numeric_limits<float>::min();
+
+        for (int i = 0; i < statCount; i++) {
+            _minOutputs.push_back(min);
+            _maxOutputs.push_back(max);
+        }
+    }
+
+public:
+    std::vector<float> _minOutputs;
+    std::vector<float> _maxOutputs;
+};
+
+
+}  // namespace InferenceEngine

inference-engine/include/ie_iexecutable_network.hpp

@@ -0,0 +1,94 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header file for IExecutableNetwork interface
+ * @file ie_iexecutable_network.hpp
+ */
+#pragma once
+
+#include "ie_common.h"
+#include "ie_primitive_info.hpp"
+#include "ie_iinfer_request.hpp"
+#include "ie_imemory_state.hpp"
+#include "ie_input_info.hpp"
+#include <string>
+#include <vector>
+#include <memory>
+#include <map>
+
+namespace InferenceEngine {
+
+/**
+ * @brief A collection that contains string as key, and const Data smart pointer as value
+ */
+using ConstOutputsDataMap = std::map<std::string, CDataPtr>;
+
+/**
+ * @brief This is an interface of an executable network
+ */
+class IExecutableNetwork : public details::IRelease {
+public:
+    /**
+     * @brief A smart pointer to the current IExecutableNetwork object
+     */
+    using Ptr = std::shared_ptr<IExecutableNetwork>;
+
+    /**
+     * @brief Gets the Executable network output Data node information. The received info is stored in the given ConstOutputsDataMap node.
+     * This method need to be called to find output names for using them later during filling of a map
+     * of blobs passed to InferenceEngine::IInferencePlugin::Infer()
+     * @param out Reference to the ConstOutputsDataMap object
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode GetOutputsInfo(ConstOutputsDataMap &out, ResponseDesc *resp) const noexcept  = 0;
+
+    /**
+     * @brief Gets the Executable network input Data node information. The received info is stored in the given ConstInputsDataMap object.
+     * This method need to be called to find out input names for using them later during filling of a map
+     * of blobs passed to InferenceEngine::IInferencePlugin::Infer()
+     * @param inputs Reference to ConstInputsDataMap object.
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode GetInputsInfo(ConstInputsDataMap &inputs, ResponseDesc *resp) const noexcept  = 0;
+
+    /**
+    * @brief Creates an inference request object used to infer the network.
+    * The created request has allocated input and output blobs (that can be changed later).
+    * @param req Shared pointer to the created request object
+    * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+    * @return Status code of the operation: OK (0) for success
+    */
+    virtual StatusCode CreateInferRequest(IInferRequest::Ptr& req, ResponseDesc *resp) noexcept = 0;
+
+    /**
+    * @brief Exports the current executable network so it can be used later in the Import() main API
+    * @param modelFileName Full path to the location of the exported file
+    * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+    * @return Status code of the operation: OK (0) for success
+    */
+    virtual StatusCode Export(const std::string& modelFileName, ResponseDesc *resp) noexcept = 0;
+
+    /**
+    * @brief Gets the mapping of IR layer names to implemented kernels
+    * @param deployedTopology Map of PrimitiveInfo objects that represent the deployed topology
+    * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+    * @return Status code of the operation: OK (0) for success
+    */
+    virtual StatusCode GetMappedTopology(std::map<std::string, std::vector<PrimitiveInfo::Ptr>> &deployedTopology, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Gets state control interface for given executable network, State control essential for recurrent networks
+     * @param pState reference to a pointer that receives internal states
+     * @param idx requested index for receiving memory state
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success, OUT_OF_BOUNDS (-6) no memory state for given index
+     */
+    virtual StatusCode  QueryState(IMemoryState::Ptr & pState, size_t  idx, ResponseDesc *resp) noexcept = 0;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/ie_iextension.h

@@ -0,0 +1,248 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief This is a header file for Inference Engine Extension Interface
+ * @file ie_iextension.h
+ */
+#pragma once
+
+#include "ie_api.h"
+#include "ie_device.hpp"
+#include "ie_layers.h"
+#include "ie_error.hpp"
+#include "ie_version.hpp"
+#include <vector>
+#include <string>
+#include <memory>
+#include <map>
+
+#include "details/ie_no_copy.hpp"
+
+
+
+#if defined(_WIN32) && defined(IMPLEMENT_INFERENCE_EXTENSION_API)
+#define INFERENCE_EXTENSION_API(TYPE) extern "C"  __declspec(dllexport) TYPE
+#else
+#define INFERENCE_EXTENSION_API(TYPE) INFERENCE_ENGINE_API(TYPE)
+#endif
+
+
+namespace InferenceEngine {
+
+/**
+ * @struct DataConfig
+ * @brief This structure describes data configuration
+ */
+struct DataConfig {
+    /**
+     * @brief Format of memory descriptor
+     */
+    TensorDesc desc;
+    /**
+     * @brief Index of in-place memory. If -1 memory cannot be in-place
+     */
+    int inPlace = -1;
+    /**
+     * @brief Flag for determination of the constant memory. If layer contains all constant memory we can calculate it on the load stage.
+     */
+    bool constant = false;
+};
+
+/**
+ * @struct LayerConfig
+ * @brief This structure describes Layer configuration
+ */
+struct LayerConfig {
+    /**
+     * @brief Supported dynamic batch. If false, dynamic batch is not supported
+     */
+    bool dynBatchSupport = false;
+    /**
+     * @brief Vector of input data configs
+     */
+    std::vector<DataConfig> inConfs;
+    /**
+     * @brief Vector of output data configs
+     */
+    std::vector<DataConfig> outConfs;
+};
+
+/**
+ * @brief This class provides interface for extension implementations
+ */
+class ILayerImpl {
+public:
+    using Ptr = std::shared_ptr<ILayerImpl>;
+
+    /**
+     * @brief Destructor
+     */
+    virtual ~ILayerImpl() = default;
+
+    /**
+     * @brief Gets all supported configurations for the current layer
+     * @param conf Vector with supported configurations
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    virtual StatusCode getSupportedConfigurations(std::vector<LayerConfig>& conf, ResponseDesc* resp) noexcept = 0;
+
+    /**
+     * @brief Initializes the implementation
+     * @param config Selected supported configuration
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    virtual StatusCode init(LayerConfig& config, ResponseDesc* resp) noexcept = 0;
+};
+
+/**
+ * @brief This class provides interface for the implementation with the custom execution code
+ */
+class ILayerExecImpl : public ILayerImpl {
+public:
+    /**
+     * @brief Execute method
+     * @param inputs Vector of blobs with input memory
+     * @param outputs Vector of blobs with output memory
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    virtual StatusCode execute(std::vector<Blob::Ptr>& inputs,
+                               std::vector<Blob::Ptr>& outputs, ResponseDesc* resp) noexcept = 0;
+};
+
+/**
+ * @brief This class provides interface for extension factories
+ */
+class ILayerImplFactory {
+public:
+    using Ptr = std::shared_ptr<ILayerImplFactory>;
+    using ImplCreator = std::function<ILayerImpl*()>;
+
+    /**
+     * @brief Destructor
+     */
+    virtual ~ILayerImplFactory() = default;
+
+    /**
+     * @deprecated
+     * @brief Sets output shapes by input shapes.
+     * @param inShapes Shapes of all inputs coming in this layer
+     * @param outShapes Generated shapes coming from this layer given the input
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    virtual StatusCode getShapes(const std::vector<TensorDesc>& inShapes, std::vector<TensorDesc>& outShapes,
+                                 ResponseDesc* resp) noexcept = 0;
+
+    /**
+     * @brief Gets all possible implementations for the given cnn Layer
+     * @param impls the vector with implementations which is ordered by priority
+     * @param resp response descriptor
+     * @return status code
+     */
+    virtual StatusCode getImplementations(std::vector<ILayerImpl::Ptr>& impls, ResponseDesc* resp) noexcept = 0;
+};
+
+/**
+ * @class IShapeInferImpl
+ * @brief This class provides interface for the implementation with the custom execution code
+ */
+class IShapeInferImpl {
+public:
+    using Ptr = std::shared_ptr<IShapeInferImpl>;
+
+    /**
+     * @brief check that reshape can be applied, that parameters and shapes are valid
+     */
+    virtual StatusCode inferShapes(const std::vector<SizeVector>& inShapes,
+                                   const std::map<std::string, std::string>& params,
+                                   const std::map<std::string, Blob::Ptr>& blobs,
+                                   std::vector<SizeVector>& outShapes,
+                                   ResponseDesc* resp) noexcept = 0;
+};
+
+/**
+ * @class IShapeInferExtension
+ * @brief This class is the reader extension interface to provide implementation for shape propagation
+ */
+class IShapeInferExtension : public InferenceEngine::details::IRelease {
+public:
+    /**
+     * @brief Sets logging callback.
+     * Logging is used to track what is going on inside.
+     * @param listener Logging sink
+     */
+    virtual void SetLogCallback(InferenceEngine::IErrorListener& listener) noexcept = 0;
+
+    /**
+     * @brief Gets extension version information and stores in versionInfo
+     * @param versionInfo Pointer to version info, will be set by plugin
+     */
+    virtual void GetVersion(const InferenceEngine::Version*& versionInfo) const noexcept = 0;
+
+    /**
+     * @brief Cleans resources up
+     */
+    virtual void Unload() noexcept = 0;
+
+    /**
+     * @brief Gets the array with types of layers which are included in the extension
+     * @param types Array to store the layer types
+     * @param size Size of the layer types array
+     * @param resp Response descriptor
+     * @return Status code
+     */
+    virtual StatusCode getPrimitiveTypes(char**& types, unsigned int& size, ResponseDesc* resp) noexcept = 0;
+
+    /**
+     * @brief Gets shape propagation implementation for the given string-type of cnn Layer
+     * @param impl the vector with implementations which is ordered by priority
+     * @param resp response descriptor
+     * @return status code
+     */
+    virtual StatusCode getShapeInferImpl(IShapeInferImpl::Ptr& impl,
+                                         const char* type,
+                                         ResponseDesc* resp) noexcept = 0;
+};
+
+/**
+ * @brief This class is the main extension interface
+ */
+class IExtension : public IShapeInferExtension {
+public:
+    virtual StatusCode getFactoryFor(ILayerImplFactory*& factory, const CNNLayer* cnnLayer,
+                                     ResponseDesc* resp) noexcept = 0;
+
+    StatusCode getShapeInferImpl(IShapeInferImpl::Ptr& impl,
+                                 const char* type,
+                                 ResponseDesc* resp) noexcept override {
+        return NOT_IMPLEMENTED;
+    };
+};
+
+using IExtensionPtr = std::shared_ptr<IExtension>;
+using IShapeInferExtensionPtr = std::shared_ptr<IShapeInferExtension>;
+
+/**
+ * @brief Creates the default instance of the extension
+ * @param ext Extension interface
+ * @param resp Response description
+ * @return Status code
+ */
+INFERENCE_EXTENSION_API(StatusCode) CreateExtension(IExtension*& ext, ResponseDesc* resp) noexcept;
+
+/**
+ * @brief Creates the default instance of the shape infer extension
+ * @param ext Shape Infer Extension interface
+ * @param resp Response description
+ * @return Status code
+ */
+INFERENCE_EXTENSION_API(StatusCode) CreateShapeInferExtension(IShapeInferExtension*& ext, ResponseDesc* resp) noexcept;
+
+
+}  // namespace InferenceEngine

inference-engine/include/ie_ihetero_plugin.hpp

@@ -0,0 +1,121 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file that provides interface to register custom hetero functionality
+ * @file ie_ihetero_plugin.hpp
+ */
+#pragma once
+#include <map>
+#include <string>
+#include <memory>
+#include <ie_icnn_network.hpp>
+#include <ie_iexecutable_network.hpp>
+#include <ie_plugin.hpp>
+
+namespace InferenceEngine {
+
+/**
+ * This interface describes a mechanism of custom loaders to be used in heterogeneous
+ * plugin during setting of affinity and loading of split sub-network to the plugins
+ * The custom loader can define addition settings for the plugins or network loading
+ * Examples of cases when this interface should be implemented in the application:
+ * 1. add custom layers to existing plugins if it is not pointed to the heterogeneous plugin
+ *  or registration of custom layer is different than supported in available public plugins
+ * 2. set affinity manually for the same plugin being initialized by different parameters,
+ *  e.g different device id
+ *  In this case there will be mapping of
+ *    Device1 > HeteroDeviceLoaderImpl1
+ *    Device2 > HeteroDeviceLoaderImpl2
+ *  the affinity should be pointed manually, the implementation of HeteroDeviceLoaderImpl1 and
+ *  HeteroDeviceLoaderImpl2 should be in the application, and these device loaders should be registered
+ *  through calling of
+ *  IHeteroInferencePlugin::SetDeviceLoader("Device1", HeteroDeviceLoaderImpl1)
+ *  IHeteroInferencePlugin::SetDeviceLoader("Device2", HeteroDeviceLoaderImpl2)
+*/
+class IHeteroDeviceLoader {
+public:
+    using Ptr = std::shared_ptr<IHeteroDeviceLoader>;
+    virtual ~IHeteroDeviceLoader() = default;
+
+    /**
+     * Loads network to the device. The instantiation of plugin should be in the implementation
+     * of the IHeteroDeviceLoader. As well setting of special config option should happen in the
+     * implementation as well
+     * @param device Loading of network should happen for this device
+     * @param ret Reference to a shared ptr of the returned executable network instance
+     * @param network Network object acquired from CNNNetReader
+     * @param config Map of configuration settings relevant only for current load operation
+     * @param resp Pointer to the response message that holds a description of an error if any occurred
+     * @return Status code of the operation. OK if succeeded
+     */
+    virtual StatusCode LoadNetwork(
+        const std::string& device,
+        IExecutableNetwork::Ptr &ret,
+        ICNNNetwork &network,
+        const std::map<std::string, std::string> &config,
+        ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @depricated Use the version with config parameter
+     * This function calls plugin function QueryNetwork for the plugin being instantiated
+     * in the implementation of IHeteroDeviceLoader
+     * @param device QueryNetwork will be executed for this device
+     * @param network Network object acquired from CNNNetReader
+     * @param res
+     */
+    virtual void QueryNetwork(const std::string &device,
+                              const ICNNNetwork &network,
+                              QueryNetworkResult &res) noexcept  = 0;
+
+    /**
+     * This function calls plugin function QueryNetwork for the plugin being instantiated
+     * in the implementation of IHeteroDeviceLoader
+     * @param device QueryNetwork will be executed for this device
+     * @param network Network object acquired from CNNNetReader
+     * @param config  Network configuration parameters
+     * @param res
+     */
+    virtual void QueryNetwork(const std::string &device,
+                              const ICNNNetwork &network,
+                              const std::map<std::string, std::string>& config,
+                              QueryNetworkResult &res) noexcept {
+        QueryNetwork(device, network, res);
+    };
+};
+
+using MapDeviceLoaders = std::map<std::string, InferenceEngine::IHeteroDeviceLoader::Ptr>;
+
+/**
+ * This interface extends regular plugin interface for heterogeneous case. Not all plugins
+ * implements it. The main purpose of this interface - to register loaders and have an ability
+ * to get default settings for affinity on certain devices.
+ */
+class IHeteroInferencePlugin : public IInferencePlugin {
+public:
+    /**
+     * Registers device loader for the device
+     * @param device - the device name being used in CNNNLayer::affinity
+     * @param loader - helper class allowing to analyze if layers are supported and allow
+     * to load network to the plugin being defined in the IHeteroDeviceLoader implementation
+     */
+    virtual void SetDeviceLoader(const std::string &device, IHeteroDeviceLoader::Ptr loader) noexcept = 0;
+
+    /**
+     * The main goal of this function to set affinity according to the options set for the plugin\
+     * implementing IHeteroInferencePlugin.
+     * This function works only if all affinity in the network are empty.
+     * @param network Network object acquired from CNNNetReader
+     * @param config Map of configuration settings
+     * @param resp Pointer to the response message that holds a description of an error if any occurred
+     * @return Status code of the operation. OK if succeeded
+     */
+    virtual StatusCode SetAffinity(
+        ICNNNetwork& network,
+        const std::map<std::string, std::string> &config,
+        ResponseDesc *resp) noexcept = 0;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/ie_iinfer_request.hpp

@@ -0,0 +1,138 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header file for IInferRequest interface
+ * @file ie_iinfer_request.hpp
+ */
+
+#pragma once
+
+#include "ie_common.h"
+#include <ie_blob.h>
+#include <memory>
+#include <string>
+#include <map>
+#include <details/ie_irelease.hpp>
+
+namespace InferenceEngine {
+
+/**
+ * @brief This is an interface of asynchronous infer request
+ */
+class IInferRequest : public details::IRelease {
+public:
+    /**
+     * @enum WaitMode
+     * @brief Enumeration to hold wait mode for IInferRequest
+     */
+    enum WaitMode : int64_t {
+        /** Wait until inference result becomes available */
+        RESULT_READY = -1,
+        /** IInferRequest doesn't block or interrupt current thread and immediately returns inference status */
+        STATUS_ONLY = 0,
+    };
+
+    using Ptr = std::shared_ptr<IInferRequest>;
+    using WeakPtr = std::weak_ptr<IInferRequest>;
+
+    /**
+     * @brief Sets input/output data to infer
+     * @note: Memory allocation does not happen
+     * @param name Name of input or output blob.
+     * @param data Reference to input or output blob. The type of a blob must match the network input precision and size.
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode SetBlob(const char *name, const Blob::Ptr &data, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Gets input/output data for inference
+     * @note: Memory allocation does not happen
+     * @param name Name of input or output blob.
+     * @param data Reference to input or output blob. The type of Blob must match the network input precision and size.
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode GetBlob(const char *name, Blob::Ptr &data, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Infers specified input(s) in synchronous mode
+     * @note blocks all methods of IInferRequest while request is ongoing (running or waiting in queue)
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode Infer(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Queries performance measures per layer to get feedback of what is the most time consuming layer
+     * @note: not all plugins provide meaningful data
+     * @param perfMap Map of layer names to profiling information for that layer
+     * @param resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode GetPerformanceCounts(std::map<std::string, InferenceEngineProfileInfo> &perfMap,
+                                            ResponseDesc *resp) const noexcept = 0;
+
+    /**
+     * @brief Waits for the result to become available. Blocks until specified millis_timeout has elapsed or the result becomes available, whichever comes first.
+     * @param millis_timeout Maximum duration in milliseconds to block for
+     * @note There are special cases when millis_timeout is equal some value of the WaitMode enum:
+     * * STATUS_ONLY - immediately returns inference status (IInferRequest::RequestStatus). It does not block or interrupt current thread
+     * * RESULT_READY - waits until inference result becomes available
+     * @param resp Optional: a pointer to an already allocated object to contain extra information of a failure (if occurred)
+     * @return Enumeration of the resulted action: OK (0) for success
+     */
+    virtual InferenceEngine::StatusCode Wait(int64_t millis_timeout, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Starts inference of specified input(s) in asynchronous mode
+     * @note: It returns immediately. Inference starts also immediately
+     * @param resp Optional: a pointer to an already allocated object to contain extra information of a failure (if occurred)
+     * @return Enumeration of the resulted action: OK (0) for success
+     */
+    virtual StatusCode StartAsync(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Completion callback definition as pointer to a function
+     * @param context Pointer to request for providing context inside callback
+     * @param code Completion result status: OK (0) for success
+     */
+    typedef void (*CompletionCallback)(InferenceEngine::IInferRequest::Ptr context,
+                                       InferenceEngine::StatusCode code);
+
+    /**
+     * @brief Sets a callback function that will be called on success or failure of asynchronous request
+     * @param callback A function to be called
+     * @return Enumeration of the resulted action: OK (0) for success
+     */
+    virtual StatusCode SetCompletionCallback(CompletionCallback callback) noexcept = 0;
+
+    /**
+     * @brief Gets arbitrary data for the request and stores a pointer to a pointer to the obtained data
+     * @param data Pointer to a pointer to the gotten arbitrary data
+     * @param resp Optional: a pointer to an already allocated object to contain extra information of a failure (if occurred)
+     * @return Enumeration of the resulted action: OK (0) for success
+     */
+    virtual StatusCode GetUserData(void **data, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief Sets arbitrary data for the request
+     * @param data Pointer to a pointer to arbitrary data to set
+     * @param resp Optional: a pointer to an already allocated object to contain extra information of a failure (if occurred)
+     * @return Enumeration of the resulted action: OK (0) for success
+     */
+    virtual StatusCode SetUserData(void *data, ResponseDesc *resp) noexcept = 0;
+
+    /**
+    * @brief Sets new batch size when dynamic batching is enabled in executable network that created this request.
+    * @param batch_size new batch size to be used by all the following inference calls for this request.
+    * @param resp Optional: a pointer to an already allocated object to contain extra information of a failure (if occurred)
+    * @return Enumeration of the resulted action: OK (0) for success
+    */
+    virtual InferenceEngine::StatusCode SetBatch(int batch_size, ResponseDesc *resp) noexcept = 0;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/ie_imemory_state.hpp

@@ -0,0 +1,61 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header file for IMemoryState interface
+ * @file ie_imemory_state.hpp
+ */
+
+#pragma once
+#include <memory>
+#include "details/ie_no_copy.hpp"
+#include "ie_common.h"
+#include "ie_blob.h"
+
+namespace InferenceEngine {
+
+/**
+ * @brief manages data for reset operations
+ */
+class IMemoryState : public details::no_copy {
+ public:
+    using Ptr = std::shared_ptr<IMemoryState>;
+
+    /**
+     * @brief Gets name of current memory state, if length of array is not enough name is truncated by len, null terminator is inserted as well.
+     * @param name preallocated buffer for receiving name
+     * @param len Length of the buffer
+     * @param  resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     */
+    virtual StatusCode GetName(char *name, size_t len, ResponseDesc *resp) const noexcept = 0;
+
+    /**
+     * @brief reset internal memory state for relevant iexecutable network, to a value specified in SetState
+     * @param  resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success*
+     */
+    virtual StatusCode Reset(ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief  Sets the new state that is used for all future Reset() operations as a base.
+     * This method can fail if Blob size does not match the internal state size or precision
+     * @param  newState is the data to use as base state
+     * @param  resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+    */
+    virtual StatusCode SetState(Blob::Ptr newState, ResponseDesc *resp) noexcept = 0;
+
+    /**
+     * @brief returns the value of the last memory state.
+     * @details Since we roll memory after each infer, we can query the input state always and still get the last state.
+     * @param lastState
+     * @param  resp Optional: pointer to an already allocated object to contain information in case of failure
+     * @return Status code of the operation: OK (0) for success
+     * */
+    virtual StatusCode GetLastState(Blob::CPtr & lastState, ResponseDesc *resp) const noexcept = 0;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/ie_input_info.hpp

@@ -0,0 +1,201 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header file for InputInfo class
+ * @file ie_input_info.hpp
+ */
+#pragma once
+
+#include <string>
+#include <memory>
+#include <map>
+#include "ie_common.h"
+#include "ie_data.h"
+#include "ie_preprocess.hpp"
+#include "ie_blob.h"
+#include "ie_precision.hpp"
+
+namespace InferenceEngine {
+
+/**
+ * @brief This class contains information about each input of the network
+ */
+class InputInfo {
+public:
+    /** @brief A smart pointer to the InputInfo instance */
+    using Ptr = std::shared_ptr<InputInfo>;
+    /** @brief A smart pointer to the constant InputInfo instance */
+    using CPtr = std::shared_ptr<const InputInfo>;
+
+    /**
+     * @deprecated it will be removed from public API. Please use getPrecision()
+     * @brief Gets a precision of the input data provided by user
+     *
+     * By default it matches the layers precision, but there are exceptions of this rule
+     * For Q78 precision networks the input is expected in I16 by default
+     * For FP16 precision networks the input is expected in FP32 by default
+     *
+     * @details By default it matches the layers precision, but there are exceptions of this rule.
+     * For Q78 precision networks the input is expected in I16 by default.
+     * For FP16 precision networks the input is expected in FP32 by default.
+     * The default input precision might be changed preferred one using setInputPrecision()
+     * function.
+     * For example, for a Q78 precision network you can pass FP32 input data
+     * @return The precision used for input blob creation
+     */
+    Precision getInputPrecision() const {
+        return getPrecision();
+    }
+
+    /**
+     * @deprecated it will be removed from public API. Please use setPrecision()
+     * @brief Changes the precision of the input data provided by the user.
+     * This function should be called before loading the network to the plugin
+     * @param p A new precision of the input data to set
+     */
+    void setInputPrecision(Precision p) {
+        setPrecision(p);
+    }
+
+    /**
+     * @brief Gets a precision of the input data provided by user
+     *
+     * By default it matches the layers precision, but there are exceptions of this rule
+     * For Q78 precision networks the input is expected in I16 by default
+     * For FP16 precision networks the input is expected in FP32 by default
+     *
+     * @details By default it matches the layers precision, but there are exceptions of this rule.
+     * For Q78 precision networks the input is expected in I16 by default.
+     * For FP16 precision networks the input is expected in FP32 by default.
+     * The default input precision might be changed preferred one using setInputPrecision()
+     * function.
+     * For example, for a Q78 precision network you can pass FP32 input data
+     * @return The precision used for input blob creation
+     */
+    Precision getPrecision() const {
+        if (!_inputData) {
+            THROW_IE_EXCEPTION << "Data is empty!";
+        }
+        return _inputData->getPrecision();
+    }
+
+    /**
+     * @brief Changes the precision of the input data provided by the user.
+     * This function should be called before loading the network to the plugin
+     * @param p A new precision of the input data to set
+     */
+    void setPrecision(Precision p) {
+        if (!_inputData) {
+            THROW_IE_EXCEPTION << "Data is empty!";
+        }
+        _inputData->setPrecision(p);
+    }
+
+    /**
+     * @brief Gets a layout of the input data provided by user
+     * @details By default it matches the layers precision and depends on number of its dimensions:
+     * C - for 1-dimensional,
+     * NC - for 2-dimensional,
+     * CHW - for 3-dimensional,
+     * NCHW - for 4-dimensional
+     * The default input layout might be changed preferred one using setLayout() function.
+     * @return The precision used for input blob creation
+     */
+    Layout getLayout() {
+        if (!_inputData) {
+            THROW_IE_EXCEPTION << "Data is empty!";
+        }
+        return _inputData->getLayout();
+    }
+
+    /**
+     * @brief Changes the layout of the input data provided by the user.
+     * This function should be called before loading the network to the plugin
+     * @param p A new layout of the input data to set
+     */
+    void setLayout(Layout l) {
+        if (!_inputData) {
+            THROW_IE_EXCEPTION << "Data is empty!";
+        }
+        _inputData->setLayout(l);
+    }
+
+    /**
+     * @brief Gets the name of the input
+     * @return A string - the name of the input
+     */
+    const std::string &name() const { return _inputData->getName(); }
+
+    /**
+     * @brief Gets the input data
+     * @return A smart pointer to the input data
+     */
+    DataPtr getInputData() {
+        return _inputData;
+    }
+
+    /**
+     * @brief Initializes the pointer to the input data that stores the main input parameters like dims, etc.
+     * This method initializes the precision with the information from the inputPtr if it was not set
+     * explicitly through setInputPrecision(). If setInputPrecision() was called, this method does not overwrite the precision.
+     * @param inputPtr Pointer to the input data to set
+     */
+    void setInputData(DataPtr inputPtr) {
+        _inputData = inputPtr;
+    }
+
+    /**
+     * @deprecated Please use getTensorDesc for working with layouts and dimensions
+     * @brief Gets dimensions/shape of the input data with reversed order
+     * @return A SizeVector object that contains dimensions of the input data. If the data is not set, the method returns an empty SizeVector object.
+     */
+    SizeVector getDims() const {
+        if (_inputData) {
+            return _inputData->dims;
+        } else {
+            return SizeVector();
+        }
+    }
+
+    /**
+     * @brief Returns the tensor descriptor
+     */
+    const TensorDesc &getTensorDesc() const {
+        if (!_inputData) {
+            THROW_IE_EXCEPTION << "Data is empty!";
+        }
+        return _inputData->getTensorDesc();
+    }
+
+    /**
+     * @brief Gets pre-process info for the input
+     * @return A reference to the PreProcessInfo instance that contains pre-process info for this input
+     */
+    PreProcessInfo &getPreProcess() { return _preProcessInfo; }
+
+protected:
+    /**
+     * @brief Pre-process info for the input
+     */
+    PreProcessInfo _preProcessInfo;
+
+    /**
+     * @brief A smart pointer to the input data
+     */
+    DataPtr _inputData;
+};
+
+/**
+ * @brief A collection that contains string as key, and InputInfo smart pointer as value
+ */
+using InputsDataMap = std::map<std::string, InputInfo::Ptr>;
+
+/**
+ * @brief A collection that contains string as key, and const InputInfo smart pointer as value
+ */
+using ConstInputsDataMap = std::map<std::string, InputInfo::CPtr>;
+
+}  // namespace InferenceEngine

inference-engine/include/ie_layers.h

@@ -0,0 +1,975 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief a header file for internal Layers structure to describe layers information
+ * @file ie_layers.h
+ */
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <map>
+#include <iterator>
+#include <cctype>
+#include "ie_common.h"
+#include "ie_data.h"
+#include "ie_blob.h"
+#include "ie_device.hpp"
+
+namespace InferenceEngine {
+/**
+ * @brief This is an internal common Layer parameter parsing arguments
+ */
+struct LayerParams {
+    /// @brief Layer name
+    std::string name;
+    /// @brief Layer type
+    std::string type;
+    /// @brief Layer precision
+    Precision precision;
+};
+
+/**
+ * @brief This is a base abstraction Layer - all DNN Layers inherit from this class
+ */
+class CNNLayer  {
+public:
+    /**
+     * @brief A shared pointer to CNNLayer
+     */
+    using  Ptr = std::shared_ptr<CNNLayer>;
+
+    /**
+     * @brief Layer name
+     */
+    std::string name;
+    /**
+     * @brief Layer type
+     */
+    std::string type;
+    /**
+     * @brief Layer base operating precision
+     */
+    Precision precision;
+    /**
+     * @brief A vector of pointers to the output data elements of this layer in the di-graph (order matters)
+     */
+    std::vector<DataPtr> outData;
+    /**
+     * @brief A vector of weak pointers to the input data elements of this layer in the di-graph (order matters)
+     */
+    std::vector<DataWeakPtr> insData;
+    /**
+     * @brief If suggested to fuse - a pointer to the layer which needs to be fused with this layer
+     */
+    Ptr _fusedWith;
+    /**
+     * @brief Convenience user values to store in this object as extra data
+     */
+    UserValue userValue;
+    /**
+     * @brief Layer affinity set by user.
+     */
+    std::string affinity;
+
+    /**
+     * @brief A constructor. Creates a new CNNLayer instance and initializes layer parameters with the given values.
+     * @param prms Basic common parsing parameters
+     */
+    explicit CNNLayer(const LayerParams &prms) : name(prms.name), type(prms.type),
+                                                 precision(prms.precision), userValue({0}) {
+    }
+
+    /**
+     * @brief A virtual destructor
+     */
+    virtual ~CNNLayer() = default;
+
+    /**
+     * @brief Sets a layer to be fused with
+     * @param layer Reference to the layer to be fused with
+     */
+    void fuse(Ptr &layer) {
+        _fusedWith = layer;
+    }
+
+    /**
+     * @brief Returns the first element of the input data for this layer
+     * @return A smart pointer to the input data element
+     */
+    virtual const DataPtr input() const {
+        if (insData.empty()) {
+            THROW_IE_EXCEPTION << "Internal error: input data is empty";
+        }
+        auto lockedFirstInsData = insData[0].lock();
+        if (!lockedFirstInsData) {
+            THROW_IE_EXCEPTION << "Internal error: unable to lock weak_ptr\n";
+        }
+        return lockedFirstInsData;
+    }
+
+    /**
+     * @brief Checks if the input data and layer data are legitimate
+     */
+    INFERENCE_ENGINE_API_CPP(void) validateLayer();
+
+    /**
+     * @brief Gets float value for the given parameter
+     * @param param - name of the parameter to find
+     * @param def - default value of the parameter if not found
+     * @return float value
+     */
+    float GetParamAsFloat(const char* param, float def) const {
+        std::string val = GetParamAsString(param, std::to_string(def).c_str());
+        try {
+            return std::stof(val);
+        } catch (...) {
+            THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " from IR for layer " << name
+                               << ". Value " << val << " cannot be casted to float.";
+        }
+    }
+
+    /**
+     * @brief Returns a float value for the given layer parameter
+     * @param param Name of the layer parameter
+     * @return A float value for the specified parameter
+     */
+    float GetParamAsFloat(const char *param) const {
+        std::string val = GetParamAsString(param);
+        try {
+            return std::stof(val);
+        } catch (...) {
+            THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " from IR for layer " << name
+                               << ". Value " << val << " cannot be casted to float.";
+        }
+    }
+
+    /**
+     * @brief Returns a vector of float values for the given parameter or returns the default value
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return vector of float values
+     */
+    std::vector<float> GetParamAsFloats(const char *param, std::vector<float> def) const {
+        std::string vals = GetParamAsString(param, "");
+        std::vector<float> result;
+        std::istringstream stream(vals);
+        std::string str;
+        if (vals.empty())
+            return def;
+        while (getline(stream, str, ',')) {
+            try {
+                result.push_back(std::stof(str));
+            } catch (...) {
+                THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " " << str << " from IR for layer " << name
+                                   << ". Value " << vals << " cannot be casted to floats.";
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @brief Returns a vector of float values for the given parameter
+     * @param param Name of the layer parameter
+     * @return vector of float values
+     */
+    std::vector<float> GetParamAsFloats(const char *param) const {
+        std::string vals = GetParamAsString(param);
+        std::vector<float> result;
+        std::istringstream stream(vals);
+        std::string str;
+        while (getline(stream, str, ',')) {
+            try {
+                result.push_back(std::stof(str));
+            } catch (...) {
+                THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " " << str << " from IR for layer " << name
+                                   << ". Value " << vals << " cannot be casted to floats.";
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @brief Returns an integer value for the given parameter or returns the default value
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return An int value for the specified parameter
+     */
+    int GetParamAsInt(const char *param, int def) const {
+        std::string val = GetParamAsString(param, std::to_string(def).c_str());
+        try {
+            return std::stoi(val);
+        } catch (...) {
+            THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " from IR for layer " << name
+                               << ". Value " << val << " cannot be casted to int.";
+        }
+    }
+
+    /**
+     * @brief Returns an integer value for the given parameter
+     * @param param Name of the layer parameter
+     * @return An int value for the specified parameter
+     */
+    int GetParamAsInt(const char *param) const {
+        std::string val = GetParamAsString(param);
+        try {
+            return std::stoi(val);
+        } catch (...) {
+            THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " from IR for layer " << name
+                               << ". Value " << val << " cannot be casted to int.";
+        }
+    }
+
+
+    /**
+     * @brief Returns a vector of int values for the given parameter or returns the default value
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return vector of int values
+     */
+    std::vector<int> GetParamAsInts(const char *param, std::vector<int> def) const {
+        std::string vals = GetParamAsString(param, "");
+        std::vector<int> result;
+        std::istringstream stream(vals);
+        std::string str;
+        if (vals.empty())
+            return def;
+        while (getline(stream, str, ',')) {
+            try {
+                result.push_back(std::stoi(str));
+            } catch (...) {
+                THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " " << str << " from IR for layer " << name
+                                   << ". Value " << vals << " cannot be casted to int.";
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @brief Returns a vector of int values for the given parameter
+     * @param param Name of the layer parameter
+     * @return vector of int values
+     */
+    std::vector<int> GetParamAsInts(const char *param) const {
+        std::string vals = GetParamAsString(param);
+        std::vector<int> result;
+        std::istringstream stream(vals);
+        std::string str;
+        while (getline(stream, str, ',')) {
+            try {
+                result.push_back(std::stoi(str));
+            } catch (...) {
+                THROW_IE_EXCEPTION << "Cannot parse parameter " << param << " " << str << " from IR for layer " << name
+                        << ". Value " << vals <<  " cannot be casted to int.";
+            }
+        }
+        return result;
+    }
+    /**
+     * @brief Returns an unsigned integer value for the given parameter or returns the default value
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return An unsigned integer value for the specified parameter
+     */
+    unsigned int GetParamAsUInt(const char *param, unsigned int def) const {
+        std::string val = GetParamAsString(param, std::to_string(def).c_str());
+        std::string message = "Cannot parse parameter " + std::string(param) + " from IR for layer " + name
+                              + ". Value " + val + " cannot be casted to int.";
+        try {
+            int value = std::stoi(val);
+            if (value < 0) {
+                THROW_IE_EXCEPTION << message;
+            }
+            return static_cast<unsigned int>(value);
+        } catch (...) {
+            THROW_IE_EXCEPTION << message;
+        }
+    }
+
+    /**
+     * @brief Returns an unsigned integer value for the given parameter
+     * @param param Name of the layer parameter
+     * @return An unsigned integer value for the specified parameter
+     */
+    unsigned int GetParamAsUInt(const char *param) const {
+        std::string val = GetParamAsString(param);
+        std::string message = "Cannot parse parameter " + std::string(param) + " from IR for layer " + name
+                                                 + ". Value " + val + " cannot be casted to int.";
+        try {
+            int value = std::stoi(val);
+            if (value < 0) {
+                THROW_IE_EXCEPTION << message;
+            }
+            return static_cast<unsigned int>(value);
+        } catch (...) {
+            THROW_IE_EXCEPTION << message;
+        }
+    }
+
+
+    /**
+     * @brief Returns a vector of unsigned int values for the given parameter or returns the default value
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return vector of unsigned int values
+     */
+    std::vector<unsigned int> GetParamAsUInts(const char *param, std::vector<unsigned int> def) const {
+        std::string vals = GetParamAsString(param, "");
+        std::vector<unsigned int> result;
+        std::istringstream stream(vals);
+        std::string str;
+        std::string message = "Cannot parse parameter " + std::string(param) + " " + str + " from IR for layer " + name
+                              + ". Value " + vals +  " cannot be casted to int.";
+        if (vals.empty())
+            return def;
+        while (getline(stream, str, ',')) {
+            try {
+                int value = std::stoi(str);
+                if (value < 0) {
+                    THROW_IE_EXCEPTION << message;
+                }
+                result.push_back(static_cast<unsigned int>(value));
+            } catch (...) {
+                THROW_IE_EXCEPTION << message;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * @brief Returns a vector of unsigned int values for the given parameter
+     * @param param Name of the layer parameter
+     * @return vector of unsigned int values
+     */
+    std::vector<unsigned int> GetParamAsUInts(const char *param) const {
+        std::string vals = GetParamAsString(param);
+        std::vector<unsigned int> result;
+        std::istringstream stream(vals);
+        std::string str;
+        std::string message = "Cannot parse parameter " + std::string(param) + " " + str + " from IR for layer " + name
+                                                        + ". Value " + vals +  " cannot be casted to int.";
+        while (getline(stream, str, ',')) {
+            try {
+                int value = std::stoi(str);
+                if (value < 0) {
+                    THROW_IE_EXCEPTION << message;
+                }
+                result.push_back(static_cast<unsigned int>(value));
+            } catch (...) {
+                THROW_IE_EXCEPTION << message;
+            }
+        }
+        return result;
+    }
+    /**
+     * @brief Returns an boolean value for the given parameter.
+     * The valid values are (true, false, 1, 0).
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return An bool value for the specified parameter
+     */
+    bool GetParamsAsBool(const char *param, bool def) const {
+        std::string val = GetParamAsString(param, std::to_string(def).c_str());
+        std::string loweredCaseValue;
+        std::transform(val.begin(), val.end(), std::back_inserter(loweredCaseValue), [](char value) {
+            return std::tolower(value);
+        });
+
+        bool result = false;
+
+        if (!(std::istringstream(loweredCaseValue) >> std::boolalpha >> result)) {
+            // attempting parse using non alpha bool
+            return static_cast<bool>(GetParamAsInt(param, def));
+        }
+
+        return result;
+    }
+
+    /**
+     * @brief Returns a string value for the given parameter or returns the default one
+     * @param param Name of the layer parameter
+     * @param def Default value of the parameter if not found
+     * @return A string value
+     */
+    std::string GetParamAsString(const char *param, const char *def) const {
+        auto it = params.find(param);
+        if (it == params.end()) {
+            return def;
+        }
+        return (*it).second;
+    }
+
+    /**
+     * @brief Returns a string value for the given parameter.
+     * Throws exception if parameter was not found.
+     * @param param Name of the layer parameter
+     * @return A string value
+     */
+    std::string GetParamAsString(const char *param) const {
+        auto it = params.find(param);
+        if (it == params.end()) {
+            THROW_IE_EXCEPTION << "No such parameter name '" << param << "' for layer " << name;
+        }
+        return (*it).second;
+    }
+
+    /**
+     * @brief Map of pairs: (parameter name, parameter value)
+     */
+    std::map<std::string, std::string> params;
+    /**
+     * @brief Map of pairs: (name, weights/biases blob)
+     */
+    std::map<std::string, Blob::Ptr> blobs;
+};
+
+/**
+ * @brief Alias for CNNLayer object
+ */
+using GenericLayer = class CNNLayer;
+
+/**
+ * @brief This class represents a layer with Weights and/or Biases (e.g. Convolution/Fully Connected, etc.)
+ */
+class WeightableLayer : public CNNLayer {
+public:
+    /**
+     * @brief A default constructor. Constructs a WeightableLayer instance and initiates layer parameters with the given values
+     * @param prms Initial layer parameters
+     */
+    explicit WeightableLayer(const LayerParams &prms) : CNNLayer(prms) {}
+
+    /**
+     * @brief A pointer to a weights blob
+     */
+    Blob::Ptr _weights;
+    /**
+     * @brief A pointer to a biases blob
+     */
+    Blob::Ptr _biases;
+
+    /**
+     * @brief Constructs a WeightableLayer instance and initiates layer parameters with the given values
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a standard 3D Convolution Layer
+ */
+class ConvolutionLayer : public WeightableLayer {
+public:
+    /**
+     * @brief A convolution kernel width
+     */
+    unsigned int _kernel_x = 0;
+    /**
+     * @brief A convolution kernel height
+     */
+    unsigned int _kernel_y = 0;
+    /**
+     * @brief An input convolution stride width
+     */
+    unsigned int _stride_x = 1;
+    /**
+     * @brief An Input convolution stride height
+     */
+    unsigned int _stride_y = 1;
+    /**
+     * @brief A number of output feature maps (size) generating the 3'rd output dimension
+     */
+    unsigned int _out_depth = 0;
+    /**
+     * @brief Input padding width
+     */
+    unsigned int _padding_x = 0;
+    /**
+     * @brief Input padding height
+     */
+    unsigned int _padding_y = 0;
+    /**
+     * @brief Dilation width
+     */
+    unsigned int _dilation_x = 1;
+    /**
+     * @brief Dilation height
+     */
+    unsigned int _dilation_y = 1;
+    /**
+     * @brief Number of groups
+     */
+    unsigned int _group = 1;
+
+    /**
+     * @brief Creates a new ConvolutionLayer instance.
+     */
+    using WeightableLayer::WeightableLayer;
+};
+
+/**
+ * @brief This class represents a standard deconvolution layer
+ */
+class DeconvolutionLayer : public WeightableLayer {
+public:
+    /**
+     * @brief Deconvolution kernel width
+     */
+    unsigned int _kernel_x = 0;
+    /**
+     * @brief Deconvolution kernel height
+     */
+    unsigned int _kernel_y = 0;
+    /**
+     * @brief Input Deconvolution stride width
+     */
+    unsigned int _stride_x = 0;
+    /**
+     * @brief Input Deconvolution stride height
+     */
+    unsigned int _stride_y = 0;
+    /**
+     * @brief number of output feature maps (size) generating the 3'rd output dimension
+     */
+    unsigned int _out_depth = 0;
+    /**
+     * @brief Input padding width
+     */
+    unsigned int _padding_x = 0;
+    /**
+     * @brief Input padding height
+     */
+    unsigned int _padding_y = 0;
+    /**
+     * @brief Dilation width
+     */
+    unsigned int _dilation_x = 0;
+    /**
+     * @brief Dilation height
+     */
+    unsigned int _dilation_y = 0;
+    /**
+     * @brief Number of groups
+     */
+    unsigned int _group = 0;
+
+    /**
+     * @brief Creates a new DeconvolutionLayer instance.
+     */
+    using WeightableLayer::WeightableLayer;
+};
+
+/**
+ * @brief This class represents a standard pooling layer
+ */
+class PoolingLayer : public CNNLayer {
+public:
+    /**
+     * @brief Pooling kernel width
+     */
+    unsigned int _kernel_x = 0;
+    /**
+     * @brief Pooling kernel height
+     */
+    unsigned int _kernel_y = 0;
+    /**
+     * @brief Input Pooling stride width
+     */
+    unsigned int _stride_x = 0;
+    /**
+     * @brief Input Pooling stride height
+     */
+    unsigned int _stride_y = 0;
+    /**
+     * @brief Input padding width
+     */
+    unsigned int _padding_x = 0;
+    /**
+     * @brief Input padding height
+     */
+    unsigned int _padding_y = 0;
+
+    /**
+     * @enum PoolType
+     * @brief Defines available pooling types
+     */
+    enum PoolType {
+        MAX = 1,
+        AVG = 2,
+        STOCH = 3,
+        ROI = 4,
+        SPACIAL_PYRAMID = 5
+    };
+
+    /**
+     * @brief A pooling type
+     */
+    PoolType _type = MAX;
+
+    /**
+     * @brief A flag that indicates if padding is excluded or not
+     */
+    bool _exclude_pad = false;
+
+    /**
+    * @brief Creates a new PoolingLayer instance.
+    */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a fully connected layer
+ */
+class FullyConnectedLayer : public WeightableLayer {
+public:
+    /**
+     * @brief A size of output
+     */
+    unsigned int _out_num = 0;
+
+    /**
+    * @brief Creates a new FullyConnectedLayer instance and initializes layer parameters with the given values.
+    */
+    using WeightableLayer::WeightableLayer;
+};
+
+/**
+ * @brief This class represents concatenation layer
+ * Takes as input several data elements and merges them to one using the supplied axis
+ */
+class ConcatLayer : public CNNLayer {
+public:
+    /**
+     * @brief An axis on which concatenation operation is performed
+     */
+    unsigned int _axis = 1;
+
+    /**
+    * @brief Creates a new ConcatLayer instance and initializes layer parameters with the given values.
+    * If batch is used, then batch needs to be specified as an input dimension also
+    * In current implementation 1 means channels, 0 - batch
+    */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a layer that evenly splits the input into the supplied outputs
+ */
+class SplitLayer : public CNNLayer {
+public:
+    /**
+     * @brief An axis on which split operation is performed
+     */
+    unsigned int _axis = 1;
+
+    /**
+    * @brief Creates a new SplitLayer instance.
+    */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a Linear Response Normalization (LRN) Layer
+ */
+class NormLayer : public CNNLayer {
+public:
+    /**
+     * @brief Response size
+     */
+    unsigned int _size = 0;
+    /**
+     * @deprecated
+     */
+    unsigned int _k = 1;
+    /**
+     * @brief Alpha coefficient
+     */
+    float _alpha = 0;
+    /**
+     * @brief Beta coefficient
+     */
+    float _beta = 0;
+    /**
+     * @brief Flag to specify normalization across feature maps (true) or across channels
+     */
+    bool _isAcrossMaps = false;
+
+    /**
+     * @brief Creates a new NormLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents standard softmax Layer
+ */
+class SoftMaxLayer : public CNNLayer {
+public:
+    /**
+     * @brief Axis number for a softmax operation
+     */
+    int axis = 1;
+    /**
+     * @brief Creates a new SoftMaxLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @class GRNLayer
+ * @brief This class represents standard GRN Layer
+ */
+class GRNLayer : public CNNLayer {
+public:
+    /**
+    * @brief A default constructor. Creates a new GRNLayer instance and initializes layer parameters with the given values.
+    * @param prms Initial layer parameters
+    */
+    explicit GRNLayer(const LayerParams &prms) : CNNLayer(prms), bias(0.f) {}
+
+    /**
+     * @brief Bias for squares sum
+     */
+    float bias = 0.f;
+};
+
+/**
+ * @class MVNLayer
+ * @brief This class represents standard MVN Layer
+ */
+class MVNLayer : public CNNLayer {
+public:
+    /**
+    * @brief A default constructor. Creates a new MVNLayer instance and initializes layer parameters with the given values.
+    * @param prms Initial layer parameters
+    */
+    explicit MVNLayer(const LayerParams &prms) : CNNLayer(prms), across_channels(0), normalize(1) {}
+
+    /**
+     * @brief Indicate that mean value is calculated across channels
+     */
+    int across_channels;
+
+    /**
+    * @brief Indicate that the result needs to be normalized
+    */
+    int normalize = 1;
+};
+
+/**
+ * @brief This class represents a Rectified Linear activation layer
+ */
+class ReLULayer : public CNNLayer {
+public:
+    /**
+     * @brief Negative slope is used to takle negative inputs instead of setting them to 0
+     */
+    float negative_slope = 0.0f;
+
+    /**
+     * @brief Creates a new ReLULayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a Clamp activation layer
+ * Clamps all tensor elements into the range [min_value, max_value]
+ */
+class ClampLayer : public CNNLayer {
+public:
+    /**
+     * @brief A minimum value
+     */
+    float min_value = 0.0f;
+
+    /**
+     * @brief A maximum value
+     */
+    float max_value = 1.0f;
+    /**
+     * @brief Creates a new ClampLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents an element wise operation layer
+ */
+class EltwiseLayer : public CNNLayer {
+public:
+    /**
+     * @enum eOperation
+     * @brief Defines possible operations that can be used
+     */
+    enum eOperation {
+        Sum = 0, Prod, Max
+    };
+
+    /**
+     * @brief A type of the operation to use
+     */
+    eOperation _operation = Sum;
+
+    /**
+     * @brief A vector of coefficients to scale the operands
+     */
+    std::vector<float> coeff;
+
+    /**
+    * @brief Creates a new EltwiseLayer instance.
+    */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a standard crop layer
+ */
+class CropLayer : public CNNLayer {
+public:
+    /**
+     * @brief A vector of dimensions for cropping
+     */
+    std::vector<int> axis;
+    /**
+     * @deprecated result size is defined by second input
+     * @brief A vector of dimensions to be preserved
+     */
+    std::vector<int> dim;
+    /**
+     * @brief A vector of offsets for each dimension
+     */
+    std::vector<int> offset;
+
+    /**
+     * @brief Creates a new CropLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a standard reshape layer
+ */
+class ReshapeLayer : public CNNLayer {
+public:
+    /**
+     * @brief A vector of sizes of the shape
+     */
+    std::vector<int> shape;
+    /**
+     * @brief A number of axis to be taken for a reshape
+     */
+    int axis = 0;
+    /**
+     * @brief A number of first axises to be taken for a reshape
+     */
+    int num_axes = -1;
+
+    /**
+     * @brief Creates a new ReshapeLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a standard Tile Layer
+ */
+class TileLayer : public CNNLayer {
+public:
+    /**
+     * @brief An index of the axis to tile
+     */
+    int axis = -1;
+    /**
+     * @brief A number of copies to be made
+     */
+    int tiles = -1;
+
+    /**
+     * @brief Creates a new TileLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+
+/**
+ * @brief This class represents a Layer which performs Scale and Shift
+ */
+class ScaleShiftLayer : public WeightableLayer {
+public:
+    /**
+     * @brief A flag that indicates if the same value is used for all the features. If false, the value is used pixel wise
+     */
+    unsigned int _broadcast = 0;
+
+    /**
+     * @brief Creates a new ScaleShiftLayer instance.
+     */
+    using WeightableLayer::WeightableLayer;
+};
+
+/**
+* @class PReLULayer
+* @brief This class represents a Layer which performs Scale and Shift
+*/
+class PReLULayer : public WeightableLayer {
+public:
+    /**
+     * @brief A flag that indicates if the same negative_slope value is used for all the features. If false, the value is used pixel wise
+     */
+    bool _channel_shared;
+
+public:
+    /**
+    * @brief A default constructor. Creates a new PReLULayer instance and initializes layer parameters with the given values.
+    * @param prms Initial layer parameters
+    */
+    explicit PReLULayer(const LayerParams &prms) : WeightableLayer(prms), _channel_shared(false) {}
+};
+
+/**
+ * @brief This class represents a standard Power Layer
+ * Formula is: output = (offset + scale * input) ^ power
+ */
+class PowerLayer : public CNNLayer {
+public:
+    /**
+     * @brief An exponent value
+     */
+    float power = 1.f;
+    /**
+     * @brief A scale factor
+     */
+    float scale = 1.f;
+    /**
+     * @brief An offset value
+     */
+    float offset = 0.f;
+
+    /**
+     * @brief Creates a new PowerLayer instance.
+     */
+    using CNNLayer::CNNLayer;
+};
+
+/**
+ * @brief This class represents a Batch Normalization Layer
+ */
+class BatchNormalizationLayer : public WeightableLayer {
+public:
+    /**
+     * @brief A small value to add to the variance estimate to avoid division by zero
+     */
+    float epsilon = 1e-3f;
+
+    /**
+     * @brief Creates a new BatchNormalizationLayer instance.
+     */
+    using WeightableLayer::WeightableLayer;
+};
+
+}  // namespace InferenceEngine

inference-engine/include/ie_layouts.h

@@ -0,0 +1,392 @@
+// Copyright (C) 2018 Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+/**
+ * @brief A header file for data layouts and conversion between them
+ * @file ie_layouts.h
+ */
+#pragma once
+
+#include <algorithm>
+
+#include "ie_api.h"
+#include "ie_common.h"
+#include "ie_precision.hpp"
+
+namespace InferenceEngine {
+
+/**
+ * @brief This class describes blocking layouts
+ */
+class INFERENCE_ENGINE_API_CLASS(BlockingDesc) {
+public:
+    /**
+     * @brief The default constructor which creates empty blocking descriptor
+     */
+    BlockingDesc();
+    /**
+     * @brief The constructor which allows to create blocking descriptors for standard layouts
+     * @param dims real dimensions
+     * @param layout memory layout
+     */
+    BlockingDesc(const SizeVector& dims, Layout layout);
+    /**
+     * @brief The constructor allows to create blocking descriptors for blocked memory
+     * @param blocked_dims blocked dimensions
+     * @param order the order of dimensions
+     */
+    BlockingDesc(const SizeVector& blocked_dims, const SizeVector& order);
+    /**
+     * @brief The constructor allows to create blocking descriptors for blocked memory
+     * @param blocked_dims blocked dimensions
+     * @param order the order of dimensions
+     * @param offset offset to the current memory block
+     */
+    BlockingDesc(const SizeVector& blocked_dims, const SizeVector& order, size_t offset);
+    /**
+     * @brief The constructor allows to create blocking descriptors for blocked memory
+     * @param blocked_dims blocked dimensions
+     * @param order the order of dimensions
+     * @param offset offset to the current memory block
+     * @param dimOffsets per-dimension offset from the padding to actual data,
+     */
+    BlockingDesc(const SizeVector& blocked_dims, const SizeVector& order, size_t offset, SizeVector dimOffsets);
+    /**
+     * @brief The constructor allows to create blocking descriptors for blocked memory
+     * @param blocked_dims blocked dimensions
+     * @param order the order of dimensions
+     * @param offset offset to the current memory block
+     * @param dimOffsets per-dimension offset from the padding to actual data,
+     * @param strides strides for each dimension
+     */
+    BlockingDesc(const SizeVector& blocked_dims, const SizeVector& order, size_t offset, SizeVector dimOffsets, SizeVector strides);
+    /**
+     * @brief Destructor
+     */
+    virtual ~BlockingDesc() = default;
+
+    /**
+     * @brief Returns the blocked dimensions vector
+     * @return blocked dimensions
+     */
+    const SizeVector& getBlockDims() const {
+        return blockedDims;
+    }
+
+    /**
+     * @brief Returns the vector of order
+     * @return order
+     */
+    const SizeVector& getOrder() const {
+        return order;
+    }
+
+    /**
+     * @brief Returns the per-dimension offset vector
+     * @return offsets
+     */
+    const SizeVector& getOffsetPaddingToData() const {
+        return offsetPaddingToData;
+    }
+
+    /**
+     * @brief Returns the offset to the current memory block
+     * @return offset
+     */
+    size_t getOffsetPadding() const {
+        return offsetPadding;
+    }
+
+    /**
+     * @brief Returns strides for each dimension
+     * @return strides
+     */
+    const SizeVector& getStrides() const {
+        return strides;
+    }
+
+    /**
+     * @brief The comparison operator for the BlockingDesc
+     * @param rhs object to compare
+     * @return true if objects are equal
+     */
+    bool operator == (const BlockingDesc& rhs) const;
+    /**
+     * @brief The comparison operator for the BlockingDesc
+     * @param rhs object to compare
+     * @return true if objects aren't equal
+     */
+    bool operator != (const BlockingDesc& rhs) const;
+
+protected:
+    void fillDesc(const SizeVector& blocked_dims, const SizeVector& order);
+
+private:
+    /** Blocked dimensions. */
+    SizeVector blockedDims;
+    /** Strides for blocked dimensions */
+    SizeVector strides;
+    /** The order of blocked dimensions **/
+    SizeVector order;
+    /** Per-dimension offset from the padding to actual data, the top-level
+     * tensor with offsets applied must lie within the padding area. */
+    SizeVector offsetPaddingToData;
+    /** Offset from memory origin to the current block, non-zero only in
+     * a description of a memory sub-block. */
+    size_t offsetPadding;
+};
+
+/**
+ * @brief This class defines Tensor description
+ */
+class INFERENCE_ENGINE_API_CLASS(TensorDesc) {
+public:
+    /**
+     * @brief The constructor creates the tensor descriptor using blocking descriptor
+     * @param precision memory precision
+     * @param dims memory dimensions
+     * @param blockDesc blocking descriptor
+     */
+    TensorDesc(const Precision& precision, SizeVector dims, const BlockingDesc& blockDesc);
+    /**
+     * @brief The constructor creates the tensor descriptor using standard layout
+     * @param precision memory precision
+     * @param dims memory dimensions
+     * @param layout memory layout
+     */
+    TensorDesc(const Precision& precision, SizeVector dims, Layout layout);
+    /**
+     * @brief The constructor creates the empty tensor descriptor with precision and layout
+     * @param precision memory precision
+     * @param layout memory layout
+     */
+    TensorDesc(const Precision& precision, Layout layout);
+    /**
+     * @brief The default constructor which creates empty tensor descriptor
+     */
+    TensorDesc();
+    /**
+     * @brief Destructor
+     */
+    virtual ~TensorDesc() = default;
+
+    /**
+     * @brief Reshapes the tensor descriptor
+     * @param dims new dimensions
+     * @param layout new layout if it is necessary
+     */
+    void reshape(const SizeVector &dims, Layout layout = Layout::ANY);
+    /**
+     * @brief Reshapes the tensor descriptor
+     * @param dims new dimensions
+     * @param blockDesc new blocking descriptor
+     */
+    void reshape(const SizeVector &dims, const BlockingDesc &blockDesc);
+
+    /**
+     * @brief Returns the vector of dimensions
+     * @return dimensions
+     */
+    SizeVector& getDims() {
+        return dims;
+    }
+    /**
+     * @brief Returns the constant vector of dimensions
+     * @return dimensions
+     */
+    const SizeVector& getDims() const {
+        return dims;
+    }
+    /**
+     * @brief Sets dimensions
+     * @param dims new dimensions
+     */
+    void setDims(const SizeVector& dims);
+
+    /**
+     * @brief Returns the memory layout
+     * @return layout
+     */
+    Layout getLayout() const {
+        return layout;
+    }
+
+    /**
+     * @brief Sets the layout
+     * @param l memory layout
+     */
+    void setLayout(Layout l) {
+        bool inconsistentLayout = false;
+        switch (layout) {
+            case Layout::C:
+                inconsistentLayout = dims.size() != 1;
+                break;
+            case Layout::OIHW:
+            case Layout::NCHW:
+            case Layout::NHWC:
+                inconsistentLayout = dims.size() != 4;
+                break;
+            case Layout::CHW:
+                inconsistentLayout = dims.size() != 3;
+                break;
+            case Layout::CN:
+            case Layout::NC:
+            case Layout::HW:
+                inconsistentLayout = dims.size() != 2;
+                break;
+            default:
+                break;
+        }
+        if (inconsistentLayout)
+            THROW_IE_EXCEPTION << "Dims and format are inconsistent.";
+        layout = l;
+    }
+
+    /**
+     * @brief Returns the memory precision
+     * @return precision
+     */
+    const Precision& getPrecision() const {
+        return precision;
+    }
+
+    /**
+     * @brief Sets the memory precision
+     * @param p precision
+     */
+    void setPrecision(const Precision& p) {
+        precision = p;
+    }
+
+    /**
+     * @brief Returns the blocking descriptor
+     * @return blocking descriptor
+     */
+    const BlockingDesc& getBlockingDesc() const {
+        return blockingDesc;
+    }
+
+    /**
+     * @brief The comparison operator for the TensorDesc
+     * @param rhs object to compare
+     * @return true if objects are equal
+     */
+    bool operator == (const TensorDesc& rhs) const;
+    /**
+     * @brief The comparison operator for the TensorDesc
+     * @param rhs object to compare
+     * @return true if objects aren't equal
+     */
+    bool operator != (const TensorDesc& rhs) const;
+
+    /**
+     * @brief Calculates offset for the vector of dimensions
+     * @param v vector of dimensions
+     * @return offset
+     */
+    size_t offset(const SizeVector& v) const;
+    /**
+     * @brief Calculates offset for the local offset
+     * @param l local offset
+     * @return offset
+     */
+    size_t offset(size_t l) const;
+
+    /**
+     * @brief Returns the standard layout for dimensions
+     * @param dims the vector of dimensions
+     * @return the standard memory layout
+     */
+    static Layout getLayoutByDims(SizeVector dims);
+private:
+    /**
+     * Memory layout
+     */
+    Layout layout;
+    /**
+     * @brief blob's dimensions
+     */
+    SizeVector dims;
+    /**
+     * @brief memory precision
+     */
+    Precision precision;
+    /**
+     * Detailed information about layout construction
+     */
+    BlockingDesc blockingDesc;
+};
+
+/**
+ * @deprecated
+ */
+static const size_t I_N = 3;
+static const size_t I_C = 2;
+static const size_t I_H = 1;
+static const size_t I_W = 0;
+
+/**
+ * @deprecated Uses TensorDesc working with layouts
+ * @brief This class helps calculating offset in different layouts
+ */
+class INFERENCE_ENGINE_API_CLASS(LayoutOffsetCounter) {
+private:
+    Layout _layout;
+    SizeVector _dims;
+
+    size_t _dims_count;
+
+    /**
+     * @brief Stores multipliers that are calculated during the LayoutOffsetCounter construction.
+     * The multipliers are used for conversion.
+     */
+    SizeVector _muls;
+public:
+    /**
+     * @brief A default constructor
+     * @param dims Tensor dimension array (reverse NCHW order as in the IR: w,h,c,n)
+     */
+    LayoutOffsetCounter(Layout layout, SizeVector dims);
+
+    /**
+     * @brief Calculates an offset for the specified layout
+     * @param pos Tensor position array (reverse NCHW order as in the IR: w,h,c,n)
+     */
+    size_t Offset(SizeVector pos);
+};
+
+/**
+ * @deprecated Please use TensorDescriptors for conversion
+ */
+template<typename T> void ConvertLayout(Layout sourceLayout, Layout destLayout, const T* sourceBuffer, T* destBuffer, SizeVector dims) {
+    if (dims.size() == 0) return;
+
+    SizeVector pos(dims.size(), 0);
+    LayoutOffsetCounter srcOffsetCounter(sourceLayout, dims);
+    LayoutOffsetCounter destOffsetCounter(destLayout, dims);
+
+    while (true) {
+        // Setting the current item
+        size_t ps = srcOffsetCounter.Offset(pos);
+        size_t pd = destOffsetCounter.Offset(pos);
+
+        destBuffer[pd] = sourceBuffer[ps];
+
+        // Advancing pos
+        size_t caret = 0;
+        pos[caret]++;
+        while (pos[caret] >= dims[caret]) {
+            pos[caret] = 0;
+            caret++;
+            if (caret == pos.size()) {
+                // We have finished converting
+                return;
+            }
+            pos[caret]++;
+        }
+    }
+}
+
+}  // namespace InferenceEngine