772 lines
26 KiB
C++
772 lines
26 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) 2023 Intel Corporation
|
|
|
|
#ifndef OPENCV_GAPI_INFER_OV_HPP
|
|
#define OPENCV_GAPI_INFER_OV_HPP
|
|
|
|
#include <string>
|
|
|
|
#include <opencv2/gapi/util/any.hpp>
|
|
#include <opencv2/gapi/own/exports.hpp> // GAPI_EXPORTS
|
|
#include <opencv2/gapi/gkernel.hpp> // GKernelType[M], GBackend
|
|
#include <opencv2/gapi/infer.hpp> // Generic
|
|
#include <opencv2/gapi/infer/workload_type.hpp>
|
|
|
|
#include <map>
|
|
|
|
namespace cv {
|
|
namespace gapi {
|
|
|
|
/**
|
|
* @brief This namespace contains G-API OpenVINO 2.0 backend functions,
|
|
* structures, and symbols.
|
|
*/
|
|
namespace ov {
|
|
|
|
GAPI_EXPORTS cv::gapi::GBackend backend();
|
|
|
|
namespace detail {
|
|
|
|
template <typename T>
|
|
using AttrMap = std::map<std::string, T>;
|
|
// NB: This type is supposed to be 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 {
|
|
struct Model {
|
|
|
|
Model(const std::string &model_path_,
|
|
const std::string &bin_path_)
|
|
: model_path(model_path_), bin_path(bin_path_) {
|
|
}
|
|
|
|
std::string model_path;
|
|
std::string bin_path;
|
|
|
|
LayerVariantAttr<std::string> input_tensor_layout;
|
|
LayerVariantAttr<std::string> input_model_layout;
|
|
LayerVariantAttr<std::string> output_tensor_layout;
|
|
LayerVariantAttr<std::string> output_model_layout;
|
|
LayerVariantAttr<int> output_tensor_precision;
|
|
|
|
LayerVariantAttr<std::vector<size_t>> new_shapes;
|
|
|
|
LayerVariantAttr<std::vector<float>> mean_values;
|
|
LayerVariantAttr<std::vector<float>> scale_values;
|
|
|
|
LayerVariantAttr<int> interpolation;
|
|
|
|
bool clamp_outputs = false;
|
|
};
|
|
|
|
struct CompiledModel {
|
|
std::string blob_path;
|
|
};
|
|
|
|
using Kind = cv::util::variant<Model, CompiledModel>;
|
|
|
|
ParamDesc(Kind &&kind_,
|
|
const std::string &device_,
|
|
const bool is_generic_,
|
|
const size_t num_in_,
|
|
const size_t num_out_)
|
|
: kind(std::move(kind_)), device(device_),
|
|
is_generic(is_generic_),
|
|
num_in(num_in_), num_out(num_out_) {
|
|
}
|
|
|
|
Kind kind;
|
|
|
|
std::string device;
|
|
bool is_generic;
|
|
|
|
std::size_t num_in;
|
|
std::size_t num_out;
|
|
|
|
std::vector<std::string> input_names;
|
|
std::vector<std::string> output_names;
|
|
|
|
using PluginConfigT = std::map<std::string, std::string>;
|
|
PluginConfigT config;
|
|
|
|
size_t nireq = 1;
|
|
|
|
bool ensure_named_tensors = false;
|
|
};
|
|
|
|
// NB: Just helper to avoid code duplication.
|
|
static detail::ParamDesc::Model&
|
|
getModelToSetAttrOrThrow(detail::ParamDesc::Kind &kind,
|
|
const std::string &attr_name) {
|
|
if (cv::util::holds_alternative<detail::ParamDesc::CompiledModel>(kind)) {
|
|
cv::util::throw_error(
|
|
std::logic_error("Specifying " + attr_name + " isn't"
|
|
" possible for compiled model."));
|
|
}
|
|
GAPI_Assert(cv::util::holds_alternative<detail::ParamDesc::Model>(kind));
|
|
return cv::util::get<detail::ParamDesc::Model>(kind);
|
|
}
|
|
|
|
} // namespace detail
|
|
|
|
/**
|
|
* @brief This structure provides functions
|
|
* that fill inference parameters for "OpenVINO Toolkit" model.
|
|
*/
|
|
template<typename Net> struct 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 Path to a model.
|
|
@param bin_path Path to a data file.
|
|
For IR format (*.bin):
|
|
If path is empty, will try to read a bin file with the same name as xml.
|
|
If the bin file with the same name is not found, will load IR without weights.
|
|
For PDPD (*.pdmodel) and ONNX (*.onnx) formats bin_path isn't used.
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &model_path,
|
|
const std::string &bin_path,
|
|
const std::string &device)
|
|
: m_desc( detail::ParamDesc::Kind{detail::ParamDesc::Model{model_path, bin_path}}
|
|
, device
|
|
, false /* is generic */
|
|
, std::tuple_size<typename Net::InArgs>::value
|
|
, std::tuple_size<typename Net::OutArgs>::value) {
|
|
}
|
|
|
|
/** @overload
|
|
Use this constructor to work with pre-compiled network.
|
|
Model is imported from a pre-compiled blob.
|
|
|
|
@param blob_path path to the compiled model (*.blob).
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &blob_path,
|
|
const std::string &device)
|
|
: m_desc( detail::ParamDesc::Kind{detail::ParamDesc::CompiledModel{blob_path}}
|
|
, device
|
|
, false /* is generic */
|
|
, std::tuple_size<typename Net::InArgs>::value
|
|
, std::tuple_size<typename Net::OutArgs>::value) {
|
|
}
|
|
|
|
/** @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 std::vector<std::string> &layer_names) {
|
|
m_desc.input_names = layer_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 std::vector<std::string> &layer_names) {
|
|
m_desc.output_names = layer_names;
|
|
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 config Map of pairs: (config parameter name, config parameter value).
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgPluginConfig(const detail::ParamDesc::PluginConfigT &config) {
|
|
m_desc.config = config;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Ensures the model has named tensors.
|
|
|
|
This function is used to ensure that all tensors in the model have names.
|
|
It goes through all input and output nodes of the model and sets the names
|
|
if they are not set. This is neccessary for models with nameless tensors.
|
|
|
|
If a tensor does not have a name, it will be assigned a default name
|
|
based on the producer node's friendly name. If the producer node has multiple
|
|
outputs, the name will be in the form "node_name:N", where N is the output index.
|
|
|
|
@param flag If true, then it guarantees that all tensors will have names.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgEnsureNamedTensors(bool flag = true) {
|
|
m_desc.ensure_named_tensors = flag;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies tensor layout for an input layer.
|
|
|
|
The function is used to set tensor layout for an input layer.
|
|
|
|
@param layout Tensor layout ("NCHW", "NWHC", etc)
|
|
will be applied to all input layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputTensorLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout")
|
|
.input_tensor_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
@param layout_map Map of pairs: name of corresponding input layer
|
|
and its tensor layout represented in std::string ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgInputTensorLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout")
|
|
.input_tensor_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies model layout for an input layer.
|
|
|
|
The function is used to set model layout for an input layer.
|
|
|
|
@param layout Model layout ("NCHW", "NHWC", etc)
|
|
will be applied to all input layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgInputModelLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout")
|
|
.input_model_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
@param layout_map Map of pairs: name of corresponding input layer
|
|
and its model layout ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgInputModelLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout")
|
|
.input_model_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies tensor layout for an output layer.
|
|
|
|
The function is used to set tensor layout for an output layer.
|
|
|
|
@param layout Tensor layout ("NCHW", "NWHC", etc)
|
|
will be applied to all output layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgOutputTensorLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout")
|
|
.output_tensor_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
@param layout_map Map of pairs: name of corresponding output layer
|
|
and its tensor layout represented in std::string ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgOutputTensorLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout")
|
|
.output_tensor_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies model layout for an output layer.
|
|
|
|
The function is used to set model layout for an output layer.
|
|
|
|
@param layout Model layout ("NCHW", "NHWC", etc)
|
|
will be applied to all output layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgOutputModelLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout")
|
|
.output_model_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
@param layout_map Map of pairs: name of corresponding output layer
|
|
and its model layout ("NCHW", "NHWC", etc)
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgOutputModelLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout")
|
|
.output_model_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies tensor precision for an output layer.
|
|
|
|
The function is used to set tensor precision for an output layer..
|
|
|
|
@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>& cfgOutputTensorPrecision(int precision) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision")
|
|
.output_tensor_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>&
|
|
cfgOutputTensorPrecision(detail::AttrMap<int> precision_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision")
|
|
.output_tensor_precision = std::move(precision_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Enables or disables clamping of model outputs in the PrePostProcessor.
|
|
|
|
By default, output values are clamped to the valid range for the output precision
|
|
by the device or plugin. Enabling this option moves clamping to the PrePostProcessor stage.
|
|
|
|
@note This feature is only available with OpenVINO 2025.2 and newer.
|
|
|
|
@param flag If true, clamping is performed in the PrePostProcessor;
|
|
otherwise, it is handled by the device or plugin.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgClampOutputs(bool flag = true) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "clamp outputs")
|
|
.clamp_outputs = std::move(flag);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies the new shape for input layers.
|
|
|
|
The function is used to set new shape for input layers.
|
|
|
|
@param new_shape New shape will be applied to all input layers.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgReshape(std::vector<size_t> new_shape) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape")
|
|
.new_shapes = std::move(new_shape);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param new_shape_map Map of pairs: name of corresponding output layer
|
|
and its new shape.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>&
|
|
cfgReshape(detail::AttrMap<std::vector<size_t>> new_shape_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape")
|
|
.new_shapes = std::move(new_shape_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies number of asynchronous inference requests.
|
|
|
|
@param nireq Number of inference asynchronous requests.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgNumRequests(const size_t nireq) {
|
|
if (nireq == 0) {
|
|
cv::util::throw_error(
|
|
std::logic_error("Number of inference requests"
|
|
" must be greater than zero."));
|
|
}
|
|
m_desc.nireq = nireq;
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies mean values for preprocessing.
|
|
*
|
|
The function is used to set mean values for input layer preprocessing.
|
|
|
|
@param mean_values Float vector contains mean values
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgMean(std::vector<float> mean_values) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values")
|
|
.mean_values = std::move(mean_values);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param mean_map Map of pairs: name of corresponding input layer
|
|
and its mean values.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgMean(detail::AttrMap<std::vector<float>> mean_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values")
|
|
.mean_values = std::move(mean_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @brief Specifies scale values for preprocessing.
|
|
*
|
|
The function is used to set scale values for input layer preprocessing.
|
|
|
|
@param scale_values Float vector contains scale values
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgScale(std::vector<float> scale_values) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values")
|
|
.scale_values = std::move(scale_values);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload
|
|
|
|
@param scale_map Map of pairs: name of corresponding input layer
|
|
and its mean values.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgScale(detail::AttrMap<std::vector<float>> scale_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values")
|
|
.scale_values = std::move(scale_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_NEAREST, #INTER_LINEAR, #INTER_CUBIC.
|
|
@return reference to this parameter structure.
|
|
*/
|
|
Params<Net>& cfgResize(int interpolation) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing")
|
|
.interpolation = std::move(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) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing")
|
|
.interpolation = std::move(interpolation);
|
|
return *this;
|
|
}
|
|
|
|
// BEGIN(G-API's network parametrization API)
|
|
GBackend backend() const { return cv::gapi::ov::backend(); }
|
|
std::string tag() const { return Net::tag(); }
|
|
cv::util::any params() const { return { m_desc }; }
|
|
// END(G-API's network parametrization API)
|
|
|
|
protected:
|
|
detail::ParamDesc m_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 specifies 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 Path to a model.
|
|
@param bin_path Path to a data file.
|
|
For IR format (*.bin):
|
|
If path is empty, will try to read a bin file with the same name as xml.
|
|
If the bin file with the same name is not found, will load IR without weights.
|
|
For PDPD (*.pdmodel) and ONNX (*.onnx) formats bin_path isn't used.
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &tag,
|
|
const std::string &model_path,
|
|
const std::string &bin_path,
|
|
const std::string &device)
|
|
: m_tag(tag),
|
|
m_desc( detail::ParamDesc::Kind{detail::ParamDesc::Model{model_path, bin_path}}
|
|
, device
|
|
, true /* is generic */
|
|
, 0u
|
|
, 0u) {
|
|
}
|
|
|
|
/** @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 blob_path path to the compiled model (*.blob).
|
|
@param device target device to use.
|
|
*/
|
|
Params(const std::string &tag,
|
|
const std::string &blob_path,
|
|
const std::string &device)
|
|
: m_tag(tag),
|
|
m_desc( detail::ParamDesc::Kind{detail::ParamDesc::CompiledModel{blob_path}}
|
|
, device
|
|
, true /* is generic */
|
|
, 0u
|
|
, 0u) {
|
|
}
|
|
|
|
/** @see ov::Params::cfgPluginConfig. */
|
|
Params& cfgPluginConfig(const detail::ParamDesc::PluginConfigT &config) {
|
|
m_desc.config = config;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgEnsureNamedTensors. */
|
|
Params& cfgEnsureNamedTensors(bool flag = true) {
|
|
m_desc.ensure_named_tensors = flag;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgInputTensorLayout. */
|
|
Params& cfgInputTensorLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout")
|
|
.input_tensor_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgInputTensorLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input tensor layout")
|
|
.input_tensor_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgInputModelLayout. */
|
|
Params& cfgInputModelLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout")
|
|
.input_model_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgInputModelLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "input model layout")
|
|
.input_model_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgOutputTensorLayout. */
|
|
Params& cfgOutputTensorLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout")
|
|
.output_tensor_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgOutputTensorLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor layout")
|
|
.output_tensor_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgOutputModelLayout. */
|
|
Params& cfgOutputModelLayout(std::string layout) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout")
|
|
.output_model_layout = std::move(layout);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgOutputModelLayout(detail::AttrMap<std::string> layout_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output model layout")
|
|
.output_model_layout = std::move(layout_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgOutputTensorPrecision. */
|
|
Params& cfgOutputTensorPrecision(int precision) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision")
|
|
.output_tensor_precision = precision;
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgOutputTensorPrecision(detail::AttrMap<int> precision_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "output tensor precision")
|
|
.output_tensor_precision = std::move(precision_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgClampOutputs. */
|
|
Params&
|
|
cfgClampOutputs(bool flag = true) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "clamp outputs")
|
|
.clamp_outputs = std::move(flag);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgReshape. */
|
|
Params& cfgReshape(std::vector<size_t> new_shape) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape")
|
|
.new_shapes = std::move(new_shape);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params&
|
|
cfgReshape(detail::AttrMap<std::vector<size_t>> new_shape_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "reshape")
|
|
.new_shapes = std::move(new_shape_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgNumRequests. */
|
|
Params& cfgNumRequests(const size_t nireq) {
|
|
if (nireq == 0) {
|
|
cv::util::throw_error(
|
|
std::logic_error("Number of inference requests"
|
|
" must be greater than zero."));
|
|
}
|
|
m_desc.nireq = nireq;
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgMean. */
|
|
Params& cfgMean(std::vector<float> mean_values) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values")
|
|
.mean_values = std::move(mean_values);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgMean(detail::AttrMap<std::vector<float>> mean_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "mean values")
|
|
.mean_values = std::move(mean_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgScale. */
|
|
Params& cfgScale(std::vector<float> scale_values) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values")
|
|
.scale_values = std::move(scale_values);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgScale(detail::AttrMap<std::vector<float>> scale_map) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "scale values")
|
|
.scale_values = std::move(scale_map);
|
|
return *this;
|
|
}
|
|
|
|
/** @see ov::Params::cfgResize. */
|
|
Params& cfgResize(int interpolation) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing")
|
|
.interpolation = std::move(interpolation);
|
|
return *this;
|
|
}
|
|
|
|
/** @overload */
|
|
Params& cfgResize(detail::AttrMap<int> interpolation) {
|
|
detail::getModelToSetAttrOrThrow(m_desc.kind, "resize preprocessing")
|
|
.interpolation = std::move(interpolation);
|
|
return *this;
|
|
}
|
|
|
|
// BEGIN(G-API's network parametrization API)
|
|
GBackend backend() const { return cv::gapi::ov::backend(); }
|
|
std::string tag() const { return m_tag; }
|
|
cv::util::any params() const { return { m_desc }; }
|
|
// END(G-API's network parametrization API)
|
|
|
|
protected:
|
|
std::string m_tag;
|
|
detail::ParamDesc m_desc;
|
|
};
|
|
|
|
} // namespace ov
|
|
|
|
namespace wip { namespace ov {
|
|
/**
|
|
* @brief Ask G-API OpenVINO backend to run only inference of model provided.
|
|
*
|
|
* G-API OpenVINO backend will perform only the inference of the model provided
|
|
* without populating input and copying back output data.
|
|
* This mode is used to evaluate the pure inference performance of the model without
|
|
* taking into account the i/o data transfer.
|
|
*/
|
|
struct benchmark_mode { };
|
|
|
|
class WorkloadTypeOV : public WorkloadType {};
|
|
using WorkloadTypeOVPtr = std::shared_ptr<cv::gapi::wip::ov::WorkloadTypeOV>;
|
|
|
|
} // namespace ov
|
|
} // namespace wip
|
|
|
|
} // namespace gapi
|
|
|
|
namespace detail
|
|
{
|
|
template<> struct CompileArgTag<cv::gapi::wip::ov::benchmark_mode>
|
|
{
|
|
static const char* tag() { return "gapi.wip.ov.benchmark_mode"; }
|
|
};
|
|
template<> struct CompileArgTag<cv::gapi::wip::ov::WorkloadTypeOVPtr>
|
|
{
|
|
static const char* tag() { return "gapi.wip.ov.workload_type"; }
|
|
};
|
|
}
|
|
|
|
} // namespace cv
|
|
|
|
#endif // OPENCV_GAPI_INFER_OV_HPP
|