712 lines
24 KiB
C++
712 lines
24 KiB
C++
// This file is part of OpenCV project.
|
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
|
// of this distribution and at http://opencv.org/license.html.
|
|
//
|
|
// Copyright (C) 2019-2023 Intel Corporation
|
|
|
|
#ifndef OPENCV_GAPI_INFER_IE_HPP
|
|
#define OPENCV_GAPI_INFER_IE_HPP
|
|
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <string>
|
|
#include <array>
|
|
#include <tuple> // tuple, tuple_size
|
|
#include <map>
|
|
|
|
#include <opencv2/gapi/opencv_includes.hpp>
|
|
#include <opencv2/gapi/util/any.hpp>
|
|
|
|
#include <opencv2/core/cvdef.h> // GAPI_EXPORTS
|
|
#include <opencv2/gapi/gkernel.hpp> // GKernelPackage
|
|
#include <opencv2/gapi/infer.hpp> // Generic
|
|
#include <opencv2/gapi/streaming/onevpl/accel_types.hpp> // Preproc Dev & Ctx
|
|
|
|
namespace cv {
|
|
namespace gapi {
|
|
// FIXME: introduce a new sub-namespace for NN?
|
|
|
|
/**
|
|
* @brief This namespace contains G-API OpenVINO backend functions,
|
|
* structures, and symbols.
|
|
*/
|
|
namespace ie {
|
|
|
|
GAPI_EXPORTS cv::gapi::GBackend backend();
|
|
|
|
/**
|
|
* Specifies how G-API and IE should trait input data
|
|
*
|
|
* In OpenCV, the same cv::Mat is used to represent both
|
|
* image and tensor data. Sometimes those are hardly distinguishable,
|
|
* so this extra parameter is used to give G-API a hint.
|
|
*
|
|
* This hint controls how G-API reinterprets the data when converting
|
|
* it to IE Blob format (and which layout/etc is assigned to this data).
|
|
*/
|
|
enum class TraitAs: int
|
|
{
|
|
TENSOR, //!< G-API traits an associated cv::Mat as a raw tensor and passes dimensions as-is
|
|
IMAGE //!< G-API traits an associated cv::Mat as an image so creates an "image" blob (NCHW/NHWC, etc)
|
|
};
|
|
|
|
using IEConfig = std::map<std::string, std::string>;
|
|
|
|
enum InferMode {Sync, Async};
|
|
|
|
namespace detail {
|
|
|
|
template <typename T>
|
|
using AttrMap = std::map<std::string, T>;
|
|
// NB: This type is used to hold in/out layers
|
|
// attributes such as precision, layout, shape etc.
|
|
//
|
|
// User can provide attributes either:
|
|
// 1. cv::util::monostate - No value specified explicitly.
|
|
// 2. Attr - value specified explicitly that should be broadcasted to all layers.
|
|
// 3. AttrMap[str->T] - map specifies value for particular layer.
|
|
template <typename Attr>
|
|
using LayerVariantAttr = cv::util::variant< cv::util::monostate
|
|
, AttrMap<Attr>
|
|
, Attr>;
|
|
|
|
struct ParamDesc {
|
|
std::string model_path;
|
|
std::string weights_path;
|
|
std::string device_id;
|
|
|
|
std::vector<std::string> input_names;
|
|
std::vector<std::string> output_names;
|
|
|
|
using ConstInput = std::pair<cv::Mat, TraitAs>;
|
|
std::unordered_map<std::string, ConstInput> const_inputs;
|
|
|
|
std::size_t num_in;
|
|
std::size_t num_out;
|
|
|
|
enum class Kind {Load, Import};
|
|
Kind kind;
|
|
bool is_generic;
|
|
IEConfig config;
|
|
|
|
std::map<std::string, std::vector<std::size_t>> reshape_table;
|
|
std::unordered_set<std::string> layer_names_to_reshape;
|
|
|
|
// NB: Number of asyncrhonious infer requests
|
|
size_t nireq;
|
|
|
|
// NB: An optional config to setup RemoteContext for IE
|
|
cv::util::any context_config;
|
|
|
|
// NB: batch_size can't be equal to 1 by default, because some of models
|
|
// have 2D (Layout::NC) input and if the first dimension not equal to 1
|
|
// net.setBatchSize(1) will overwrite it.
|
|
cv::optional<size_t> batch_size;
|
|
|
|
cv::optional<cv::gapi::wip::onevpl::Device> vpl_preproc_device;
|
|
cv::optional<cv::gapi::wip::onevpl::Context> vpl_preproc_ctx;
|
|
|
|
InferMode mode;
|
|
|
|
using PrecisionT = int;
|
|
using PrecisionMapT = std::unordered_map<std::string, PrecisionT>;
|
|
// NB: This parameter can contain:
|
|
// 1. cv::util::monostate - Don't specify precision, but use default from IR/Blob.
|
|
// 2. PrecisionT (CV_8U, CV_32F, ...) - Specifies precision for all output layers.
|
|
// 3. PrecisionMapT ({{"layer0", CV_32F}, {"layer1", CV_16F}} - Specifies precision for certain output layer.
|
|
// cv::util::monostate is default value that means precision wasn't specified.
|
|
using PrecisionVariantT = cv::util::variant<cv::util::monostate,
|
|
PrecisionT,
|
|
PrecisionMapT>;
|
|
|
|
PrecisionVariantT output_precision;
|
|
LayerVariantAttr<std::string> input_layout;
|
|
LayerVariantAttr<std::string> output_layout;
|
|
LayerVariantAttr<int> interpolation;
|
|
};
|
|
} // namespace detail
|
|
|
|
// FIXME: this is probably a shared (reusable) thing
|
|
template<typename Net>
|
|
struct PortCfg {
|
|
using In = std::array
|
|
< std::string
|
|
, std::tuple_size<typename Net::InArgs>::value >;
|
|
using Out = std::array
|
|
< std::string
|
|
, std::tuple_size<typename Net::OutArgs>::value >;
|
|
};
|
|
|
|
/**
|
|
* @brief This structure provides functions
|
|
* that fill inference parameters for "OpenVINO Toolkit" model.
|
|
*/
|
|
template<typename Net> class Params {
|
|
public:
|
|
/** @brief Class constructor.
|
|
|
|
Constructs Params based on model information and specifies default values for other
|
|
inference description parameters. Model is loaded and compiled using "OpenVINO Toolkit".
|
|
|
|
@param model Path to topology IR (.xml file).
|
|
@param weights Path to weights (.bin file).
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &model,
|
|
const std::string &weights,
|
|
const std::string &device)
|
|
: desc{ model, weights, device, {}, {}, {}
|
|
, std::tuple_size<typename Net::InArgs>::value // num_in
|
|
, std::tuple_size<typename Net::OutArgs>::value // num_out
|
|
, detail::ParamDesc::Kind::Load
|
|
, false
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, 1u
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, InferMode::Async
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, {} } {
|
|
}
|
|
|
|
/** @overload
|
|
Use this constructor to work with pre-compiled network.
|
|
Model is imported from a pre-compiled blob.
|
|
|
|
@param model Path to model.
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &model,
|
|
const std::string &device)
|
|
: desc{ model, {}, device, {}, {}, {}
|
|
, std::tuple_size<typename Net::InArgs>::value // num_in
|
|
, std::tuple_size<typename Net::OutArgs>::value // num_out
|
|
, detail::ParamDesc::Kind::Import
|
|
, false
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, 1u
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, InferMode::Async
|
|
, {}
|
|
, {}
|
|
, {}
|
|
, {} } {
|
|
}
|
|
|
|
/** @brief Specifies sequence of network input layers names for inference.
|
|
|
|
The function is used to associate cv::gapi::infer<> inputs with the model inputs.
|
|
Number of names has to match the number of network inputs as defined in G_API_NET().
|
|
In case a network has only single input layer, there is no need to specify name manually.
|
|
|
|
@param layer_names std::array<std::string, N> where N is the number of inputs
|
|
as defined in the @ref G_API_NET. Contains names of input layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputLayers(const typename PortCfg<Net>::In &layer_names) {
|
|
desc.input_names.clear();
|
|
desc.input_names.reserve(layer_names.size());
|
|
std::copy(layer_names.begin(), layer_names.end(),
|
|
std::back_inserter(desc.input_names));
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies sequence of network output layers names for inference.
|
|
|
|
The function is used to associate cv::gapi::infer<> outputs with the model outputs.
|
|
Number of names has to match the number of network outputs as defined in G_API_NET().
|
|
In case a network has only single output layer, there is no need to specify name manually.
|
|
|
|
@param layer_names std::array<std::string, N> where N is the number of outputs
|
|
as defined in the @ref G_API_NET. Contains names of output layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgOutputLayers(const typename PortCfg<Net>::Out &layer_names) {
|
|
desc.output_names.clear();
|
|
desc.output_names.reserve(layer_names.size());
|
|
std::copy(layer_names.begin(), layer_names.end(),
|
|
std::back_inserter(desc.output_names));
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies a constant input.
|
|
|
|
The function is used to set a constant input. This input has to be
|
|
a preprocessed tensor if its type is TENSOR. Need to provide name of the
|
|
network layer which will receive provided data.
|
|
|
|
@param layer_name Name of network layer.
|
|
@param data cv::Mat that contains data which will be associated with network layer.
|
|
@param hint Input type @sa cv::gapi::ie::TraitAs.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& constInput(const std::string &layer_name,
|
|
const cv::Mat &data,
|
|
TraitAs hint = TraitAs::TENSOR) {
|
|
desc.const_inputs[layer_name] = {data, hint};
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies OpenVINO plugin configuration.
|
|
|
|
The function is used to set configuration for OpenVINO plugin. Some parameters
|
|
can be different for each plugin. Please follow https://docs.openvinotoolkit.org/latest/index.html
|
|
to check information about specific plugin.
|
|
|
|
@param cfg Map of pairs: (config parameter name, config parameter value).
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params& pluginConfig(const IEConfig& cfg) {
|
|
desc.config = cfg;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
Function with a rvalue parameter.
|
|
|
|
@param cfg rvalue map of pairs: (config parameter name, config parameter value).
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params& pluginConfig(IEConfig&& cfg) {
|
|
desc.config = std::move(cfg);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies configuration for RemoteContext in InferenceEngine.
|
|
|
|
When RemoteContext is configured the backend imports the networks using the context.
|
|
It also expects cv::MediaFrames to be actually remote, to operate with blobs via the context.
|
|
|
|
@param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params& cfgContextParams(const cv::util::any& ctx_cfg) {
|
|
desc.context_config = ctx_cfg;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
Function with an rvalue parameter.
|
|
|
|
@param ctx_cfg cv::util::any value which holds InferenceEngine::ParamMap.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params& cfgContextParams(cv::util::any&& ctx_cfg) {
|
|
desc.context_config = std::move(ctx_cfg);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies number of asynchronous inference requests.
|
|
|
|
@param nireq Number of inference asynchronous requests.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params& cfgNumRequests(size_t nireq) {
|
|
GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!");
|
|
desc.nireq = nireq;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies new input shapes for the network inputs.
|
|
|
|
The function is used to specify new input shapes for the network inputs.
|
|
Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1networkNetwork.html
|
|
for additional information.
|
|
|
|
@param reshape_table Map of pairs: name of corresponding data and its dimension.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputReshape(const std::map<std::string, std::vector<std::size_t>>& reshape_table) {
|
|
desc.reshape_table = reshape_table;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params<Net>& cfgInputReshape(std::map<std::string, std::vector<std::size_t>>&& reshape_table) {
|
|
desc.reshape_table = std::move(reshape_table);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param layer_name Name of layer.
|
|
@param layer_dims New dimensions for this layer.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputReshape(const std::string& layer_name, const std::vector<size_t>& layer_dims) {
|
|
desc.reshape_table.emplace(layer_name, layer_dims);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params<Net>& cfgInputReshape(std::string&& layer_name, std::vector<size_t>&& layer_dims) {
|
|
desc.reshape_table.emplace(layer_name, layer_dims);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param layer_names set of names of network layers that will be used for network reshape.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputReshape(const std::unordered_set<std::string>& layer_names) {
|
|
desc.layer_names_to_reshape = layer_names;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param layer_names rvalue set of the selected layers will be reshaped automatically
|
|
its input image size.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputReshape(std::unordered_set<std::string>&& layer_names) {
|
|
desc.layer_names_to_reshape = std::move(layer_names);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies the inference batch size.
|
|
|
|
The function is used to specify inference batch size.
|
|
Follow https://docs.openvinotoolkit.org/latest/classInferenceEngine_1_1CNNNetwork.html#a8e9d19270a48aab50cb5b1c43eecb8e9 for additional information
|
|
|
|
@param size batch size which will be used.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgBatchSize(const size_t size) {
|
|
desc.batch_size = cv::util::make_optional(size);
|
|
return *this;
|
|
}
|
|
|
|
Params<Net>& cfgPreprocessingParams(const cv::gapi::wip::onevpl::Device &device,
|
|
const cv::gapi::wip::onevpl::Context &ctx) {
|
|
desc.vpl_preproc_device = cv::util::make_optional(device);
|
|
desc.vpl_preproc_ctx = cv::util::make_optional(ctx);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies which api will be used to run inference.
|
|
|
|
The function is used to specify mode for OpenVINO inference.
|
|
OpenVINO has two options to run inference:
|
|
1. Asynchronous (using StartAsync: https://docs.openvino.ai/latest/classInferenceEngine_1_1InferRequest.html#doxid-class-inference-engine-1-1-infer-request-1a405293e8423d82a5b45f642a3bef0d24)
|
|
2. Synchronous (using Infer: https://docs.openvino.ai/latest/classInferenceEngine_1_1InferRequest.html#doxid-class-inference-engine-1-1-infer-request-1a3391ce30894abde730523e9ca9371ce8)
|
|
By default asynchronous mode is used.
|
|
|
|
@param mode Inference mode which will be used.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInferMode(InferMode mode) {
|
|
desc.mode = mode;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies the output precision for model.
|
|
|
|
The function is used to set an output precision for model.
|
|
|
|
@param precision Precision in OpenCV format (CV_8U, CV_32F, ...)
|
|
will be applied to all output layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgOutputPrecision(detail::ParamDesc::PrecisionT precision) {
|
|
desc.output_precision = precision;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param precision_map Map of pairs: name of corresponding output layer
|
|
and its precision in OpenCV format (CV_8U, CV_32F, ...)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgOutputPrecision(detail::ParamDesc::PrecisionMapT precision_map) {
|
|
desc.output_precision = precision_map;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies the input layout for model.
|
|
|
|
The function is used to set an input layout for model.
|
|
|
|
@param layout Layout in string representation ("NCHW", "NHWC", etc)
|
|
will be applied to all input layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputLayout(std::string layout) {
|
|
desc.input_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param layout_map Map of pairs: name of corresponding input layer
|
|
and its layout in string representation ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgInputLayout(detail::AttrMap<std::string> layout_map) {
|
|
desc.input_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies the output layout for model.
|
|
|
|
The function is used to set an output layout for model.
|
|
|
|
@param layout Layout in string representation ("NCHW", "NHWC", etc)
|
|
will be applied to all output layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgOutputLayout(std::string layout) {
|
|
desc.output_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param layout_map Map of pairs: name of corresponding output layer
|
|
and its layout in string representation ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgOutputLayout(detail::AttrMap<std::string> layout_map) {
|
|
desc.output_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies resize interpolation algorithm.
|
|
*
|
|
The function is used to configure resize preprocessing for input layer.
|
|
|
|
@param interpolation Resize interpolation algorithm.
|
|
Supported algorithms: #INTER_LINEAR, #INTER_AREA.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgResize(int interpolation) {
|
|
desc.interpolation = interpolation;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param interpolation Map of pairs: name of corresponding input layer
|
|
and its resize algorithm.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgResize(detail::AttrMap<int> interpolation) {
|
|
desc.interpolation = std::move(interpolation);
|
|
return *this;
|
|
}
|
|
|
|
// BEGIN(G-API's network parametrization API)
|
|
GBackend backend() const { return cv::gapi::ie::backend(); }
|
|
std::string tag() const { return Net::tag(); }
|
|
cv::util::any params() const { return { desc }; }
|
|
// END(G-API's network parametrization API)
|
|
|
|
protected:
|
|
detail::ParamDesc desc;
|
|
};
|
|
|
|
/*
|
|
* @brief This structure provides functions for generic network type that
|
|
* fill inference parameters.
|
|
* @see struct Generic
|
|
*/
|
|
template<>
|
|
class Params<cv::gapi::Generic> {
|
|
public:
|
|
/** @brief Class constructor.
|
|
|
|
Constructs Params based on model information and sets default values for other
|
|
inference description parameters. Model is loaded and compiled using OpenVINO Toolkit.
|
|
|
|
@param tag string tag of the network for which these parameters are intended.
|
|
@param model path to topology IR (.xml file).
|
|
@param weights path to weights (.bin file).
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &tag,
|
|
const std::string &model,
|
|
const std::string &weights,
|
|
const std::string &device)
|
|
: desc{ model, weights, device, {}, {}, {}, 0u, 0u,
|
|
detail::ParamDesc::Kind::Load, true, {}, {}, {}, 1u,
|
|
{}, {}, {}, {}, InferMode::Async, {}, {}, {}, {} },
|
|
m_tag(tag) {
|
|
}
|
|
|
|
/** @overload
|
|
|
|
This constructor for pre-compiled networks. Model is imported from pre-compiled
|
|
blob.
|
|
|
|
@param tag string tag of the network for which these parameters are intended.
|
|
@param model path to model.
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &tag,
|
|
const std::string &model,
|
|
const std::string &device)
|
|
: desc{ model, {}, device, {}, {}, {}, 0u, 0u,
|
|
detail::ParamDesc::Kind::Import, true, {}, {}, {}, 1u,
|
|
{}, {}, {}, {}, InferMode::Async, {}, {}, {}, {} },
|
|
m_tag(tag) {
|
|
}
|
|
|
|
/** @see ie::Params::pluginConfig. */
|
|
Params& pluginConfig(const IEConfig& cfg) {
|
|
desc.config = cfg;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& pluginConfig(IEConfig&& cfg) {
|
|
desc.config = std::move(cfg);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::constInput. */
|
|
Params& constInput(const std::string &layer_name,
|
|
const cv::Mat &data,
|
|
TraitAs hint = TraitAs::TENSOR) {
|
|
desc.const_inputs[layer_name] = {data, hint};
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgNumRequests. */
|
|
Params& cfgNumRequests(size_t nireq) {
|
|
GAPI_Assert(nireq > 0 && "Number of infer requests must be greater than zero!");
|
|
desc.nireq = nireq;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgInputReshape */
|
|
Params& cfgInputReshape(const std::map<std::string, std::vector<std::size_t>>&reshape_table) {
|
|
desc.reshape_table = reshape_table;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgInputReshape(std::map<std::string, std::vector<std::size_t>> && reshape_table) {
|
|
desc.reshape_table = std::move(reshape_table);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgInputReshape(std::string && layer_name, std::vector<size_t> && layer_dims) {
|
|
desc.reshape_table.emplace(layer_name, layer_dims);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgInputReshape(const std::string & layer_name, const std::vector<size_t>&layer_dims) {
|
|
desc.reshape_table.emplace(layer_name, layer_dims);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgInputReshape(std::unordered_set<std::string> && layer_names) {
|
|
desc.layer_names_to_reshape = std::move(layer_names);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgInputReshape(const std::unordered_set<std::string>&layer_names) {
|
|
desc.layer_names_to_reshape = layer_names;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgBatchSize */
|
|
Params& cfgBatchSize(const size_t size) {
|
|
desc.batch_size = cv::util::make_optional(size);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgInferAPI */
|
|
Params& cfgInferMode(InferMode mode) {
|
|
desc.mode = mode;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgOutputPrecision */
|
|
Params& cfgOutputPrecision(detail::ParamDesc::PrecisionT precision) {
|
|
desc.output_precision = precision;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgOutputPrecision(detail::ParamDesc::PrecisionMapT precision_map) {
|
|
desc.output_precision = precision_map;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgInputLayout */
|
|
Params& cfgInputLayout(std::string layout) {
|
|
desc.input_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgInputLayout(detail::AttrMap<std::string> layout_map) {
|
|
desc.input_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgOutputLayout */
|
|
Params& cfgOutputLayout(std::string layout) {
|
|
desc.output_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgOutputLayout(detail::AttrMap<std::string> layout_map) {
|
|
desc.output_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ie::Params::cfgResize */
|
|
Params& cfgResize(int interpolation) {
|
|
desc.interpolation = interpolation;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgResize(detail::AttrMap<int> interpolation) {
|
|
desc.interpolation = std::move(interpolation);
|
|
return *this;
|
|
}
|
|
|
|
// BEGIN(G-API's network parametrization API)
|
|
GBackend backend() const { return cv::gapi::ie::backend(); }
|
|
std::string tag() const { return m_tag; }
|
|
cv::util::any params() const { return { desc }; }
|
|
// END(G-API's network parametrization API)
|
|
|
|
protected:
|
|
detail::ParamDesc desc;
|
|
std::string m_tag;
|
|
};
|
|
|
|
} // namespace ie
|
|
} // namespace gapi
|
|
} // namespace cv
|
|
|
|
#endif // OPENCV_GAPI_INFER_IE_HPP
|