432 lines
11 KiB
C++
432 lines
11 KiB
C++
// Copyright (C) 2018-2019 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
//
|
|
|
|
/**
|
|
* @brief a header file for the Inference Engine Network interface
|
|
* @file ie_inetwork.hpp
|
|
*/
|
|
#pragma once
|
|
|
|
#include <utility>
|
|
#include <string>
|
|
#include <memory>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <ie_parameter.hpp>
|
|
#include <ie_context.hpp>
|
|
#include <ie_layouts.h>
|
|
#include <ie_blob.h>
|
|
|
|
namespace InferenceEngine {
|
|
|
|
/**
|
|
* @brief A type of network objects indexes.
|
|
*/
|
|
using idx_t = size_t;
|
|
|
|
/**
|
|
* @brief This class contains a pair from layerId and port index
|
|
*/
|
|
class PortInfo {
|
|
public:
|
|
/**
|
|
* @brief The constructor creates a PortInfo object for port 0
|
|
* @param layerID Layer id
|
|
*/
|
|
PortInfo(idx_t layerID): layer(layerID), port(0) {} // NOLINT
|
|
|
|
/**
|
|
* @brief The constructor creates a PortInfo object
|
|
* @param layerID Layer id
|
|
* @param portID Port id
|
|
*/
|
|
PortInfo(idx_t layerID, idx_t portID): layer(layerID), port(portID) {}
|
|
|
|
/**
|
|
* @brief Get layer id
|
|
* @return Layer id
|
|
*/
|
|
idx_t layerId() const {
|
|
return layer;
|
|
}
|
|
|
|
/**
|
|
* @brief Get port id
|
|
* @return Port id
|
|
*/
|
|
idx_t portId() const {
|
|
return port;
|
|
}
|
|
|
|
/**
|
|
* @brief Compares the given PortInfo object with the current one
|
|
* @param portInfo PortInfo object to compare with
|
|
* @return true if the given PortInfo object is equal to the current one, false - otherwise
|
|
*/
|
|
bool operator==(const PortInfo& portInfo) const {
|
|
return layer == portInfo.layerId() && port == portInfo.portId();
|
|
}
|
|
|
|
/**
|
|
* @brief Checks if the given PortInfo object is not equal to the current one
|
|
* @param portInfo PortInfo object to compare with
|
|
* @return true if the given PortInfo object is not equal to the current one, false - otherwise
|
|
*/
|
|
bool operator!=(const PortInfo& portInfo) const {
|
|
return !(*this == portInfo);
|
|
}
|
|
|
|
private:
|
|
idx_t layer;
|
|
idx_t port;
|
|
};
|
|
|
|
/**
|
|
* @brief This class is the main object to describe the Inference Engine connection.
|
|
*/
|
|
class Connection {
|
|
public:
|
|
/**
|
|
* @brief Constructor of a connection object.
|
|
* @param input pair of the index of input layer and the index of output port
|
|
* @param output pair of the index of output layer and the index of input port
|
|
*/
|
|
Connection(const PortInfo& input, const PortInfo& output): input(input), output(output) {}
|
|
|
|
/**
|
|
* @brief Compares the given Connection with the current one
|
|
* @param connection Connection to compare with
|
|
* @return true if the given Connection is equal to the current one, false - otherwise
|
|
*/
|
|
bool operator==(const Connection& connection) const {
|
|
return input == connection.from() && output == connection.to();
|
|
}
|
|
|
|
/**
|
|
* @brief Checks if the given Connection is not equal to the current one
|
|
* @param connection Connection to compare with
|
|
* @return true if the given Connection is not equal to the current one, false - otherwise
|
|
*/
|
|
bool operator!=(const Connection& connection) const {
|
|
return !(*this == connection);
|
|
}
|
|
|
|
/**
|
|
* Returns a constant reference to a pair of input layer index and output port index.
|
|
* @return pair of the index of input layer and the index of output port
|
|
*/
|
|
const PortInfo& from() const {
|
|
return input;
|
|
}
|
|
|
|
/**
|
|
* Returns a constant reference to a pair of output layer index and input port index.
|
|
* @return pair of the index of output layer and the index of input port
|
|
*/
|
|
const PortInfo& to() const {
|
|
return output;
|
|
}
|
|
|
|
private:
|
|
PortInfo input;
|
|
PortInfo output;
|
|
};
|
|
|
|
/**
|
|
* This class describes port data
|
|
*/
|
|
class INFERENCE_ENGINE_API_CLASS(PortData) {
|
|
public:
|
|
/**
|
|
* @brief A shared pointer to the PortData object.
|
|
*/
|
|
using Ptr = std::shared_ptr<PortData>;
|
|
|
|
/**
|
|
* @brief Default constructor
|
|
*/
|
|
PortData();
|
|
|
|
/**
|
|
* Creates port data with precision and shape
|
|
* @param shape Dimensions
|
|
* @param precision Precision
|
|
*/
|
|
PortData(const SizeVector& shape, const Precision& precision);
|
|
|
|
/**
|
|
* @brief virtual destructor
|
|
*/
|
|
virtual ~PortData() = default;
|
|
|
|
/**
|
|
* @brief Returns data
|
|
* @return Blob with data
|
|
*/
|
|
const Blob::Ptr& getData() const;
|
|
|
|
/**
|
|
* @brief Sets data
|
|
* @param data Blob with data
|
|
*/
|
|
void setData(const Blob::Ptr& data);
|
|
|
|
/**
|
|
* @brief Returns data parameters
|
|
* @return Map of parameters
|
|
*/
|
|
const std::map<std::string, Parameter>& getParameters() const noexcept;
|
|
|
|
/**
|
|
* @brief Sets new shapes for data
|
|
* @param shape New shapes
|
|
*/
|
|
void setShape(const SizeVector& shape);
|
|
|
|
private:
|
|
Blob::Ptr data;
|
|
std::map<std::string, Parameter> parameters;
|
|
|
|
void createData(const TensorDesc& desc);
|
|
};
|
|
|
|
/**
|
|
* @brief This class is the main object to describe the Inference Engine port.
|
|
*/
|
|
class INFERENCE_ENGINE_API_CLASS(Port) {
|
|
public:
|
|
/**
|
|
* @brief Default constructor of a port object.
|
|
*/
|
|
Port();
|
|
/**
|
|
* @brief Constructor of a port object with shapes.
|
|
* @param shapes port shapes
|
|
* @param precision Port precision
|
|
*/
|
|
explicit Port(const SizeVector& shapes,
|
|
const Precision& precision = Precision::UNSPECIFIED);
|
|
|
|
/**
|
|
* @brief Copy constructor.
|
|
* @param port object to copy
|
|
*/
|
|
Port(const Port& port);
|
|
|
|
/**
|
|
* @brief Virtual destructor
|
|
*/
|
|
virtual ~Port() = default;
|
|
|
|
/**
|
|
* @brief Compares the given Port with the current one
|
|
* @param rhs Port to compare with
|
|
* @return true if the given Port is equal to the current one, false - otherwise
|
|
*/
|
|
bool operator== (const Port& rhs) const;
|
|
|
|
/**
|
|
* @brief Compares the given Port with the current one
|
|
* @param rhs Port to compare with
|
|
* @return true if the given Port is NOT equal to the current one, false - otherwise
|
|
*/
|
|
bool operator!= (const Port& rhs) const;
|
|
|
|
/**
|
|
* @brief Returns a constant reference to a vector with shapes.
|
|
* Shapes should be initialized if shape is empty.
|
|
* @return constant reference to shapes
|
|
*/
|
|
const SizeVector& shape() const noexcept;
|
|
|
|
/**
|
|
* @brief Sets new shapes for current port
|
|
* @param shape New shapes
|
|
*/
|
|
void setShape(const SizeVector& shape);
|
|
|
|
/**
|
|
* @brief Returns a constant reference to parameters
|
|
* @return Map with parameters
|
|
*/
|
|
const std::map<std::string, Parameter>& getParameters() const noexcept;
|
|
|
|
/**
|
|
* @brief Sets new parameters for current port
|
|
* @param params New parameters
|
|
*/
|
|
void setParameters(const std::map<std::string, Parameter>& params) noexcept;
|
|
|
|
/**
|
|
* @brief Sets the new parameter for current port
|
|
* @param name Name of parameter
|
|
* @param param New value
|
|
*/
|
|
void setParameter(const std::string& name, const Parameter& param);
|
|
|
|
/**
|
|
* @brief Returns port data
|
|
* @return Port data
|
|
*/
|
|
const PortData::Ptr& getData() const noexcept;
|
|
|
|
/**
|
|
* @brief Sets new port data for current port
|
|
* @param data Port data
|
|
*/
|
|
void setData(const PortData::Ptr& data);
|
|
|
|
private:
|
|
std::map<std::string, Parameter> parameters;
|
|
PortData::Ptr data;
|
|
};
|
|
|
|
class INetwork;
|
|
template <class T>
|
|
class INetwotkIterator;
|
|
|
|
/**
|
|
* @brief This class is the main interface to describe the Inference Engine layer.
|
|
* All methods here are constant and do not throw exceptions.
|
|
*/
|
|
class ILayer {
|
|
public:
|
|
/**
|
|
* @brief A shared pointer to the const ILayer object
|
|
*/
|
|
using CPtr = std::shared_ptr<const ILayer>;
|
|
|
|
/**
|
|
* @brief Virtual destructor for the layer interface
|
|
*/
|
|
virtual ~ILayer() = default;
|
|
|
|
/**
|
|
* @brief Returns a id of the layer.
|
|
* @return Layer id
|
|
*/
|
|
virtual idx_t getId() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a layer name.
|
|
* @return Layer name
|
|
*/
|
|
virtual const std::string& getName() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a layer type.
|
|
* @return Layer type
|
|
*/
|
|
virtual const std::string& getType() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant smart pointer reference to a Parameters interface.
|
|
* @return Parameters interface smart pointer
|
|
*/
|
|
virtual const std::map<std::string, Parameter>& getParameters() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant reference to a vector with input ports.
|
|
* @return Vector of input ports
|
|
*/
|
|
virtual const std::vector<Port>& getInputPorts() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant reference to a vector with output ports.
|
|
* @return Vector of output ports
|
|
*/
|
|
virtual const std::vector<Port>& getOutputPorts() const noexcept = 0;
|
|
};
|
|
|
|
namespace details {
|
|
|
|
template<class NT, class LT>
|
|
class INetworkIterator;
|
|
|
|
} // namespace details
|
|
|
|
/**
|
|
* @brief This class is the main interface to describe the Inference Engine network.
|
|
*
|
|
* All methods here are constant and do not throw exceptions.
|
|
*/
|
|
class INetwork {
|
|
public:
|
|
/**
|
|
* @brief A shared pointer to the constant INetwork object.
|
|
*/
|
|
using CPtr = std::shared_ptr<const INetwork>;
|
|
/**
|
|
* @brief A constant iterator for INetwork definition
|
|
*/
|
|
using const_iterator = details::INetworkIterator<const INetwork, const ILayer>;
|
|
|
|
/**
|
|
* @brief Virtual destructor for the network interface
|
|
*/
|
|
virtual ~INetwork() = default;
|
|
|
|
/**
|
|
* @brief Begin network iterator
|
|
* @return const INetwork iterator
|
|
*/
|
|
virtual const_iterator begin() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief End network iterator
|
|
* @return const INetwork iterator
|
|
*/
|
|
virtual const_iterator end() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a number of layers in the network.
|
|
* @return Layers count
|
|
*/
|
|
virtual size_t size() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant smart pointer to a Layer interface.
|
|
* If the layer is missing, returns nullptr.
|
|
* @param id Id of the Layer
|
|
* @return Layer interface smart pointer
|
|
*/
|
|
virtual const ILayer::CPtr getLayer(idx_t id) const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant vector of input layers.
|
|
* @return Vector of input layers
|
|
*/
|
|
virtual const std::vector<ILayer::CPtr> getInputs() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant vector of output layers.
|
|
* @return Vector of output layers
|
|
*/
|
|
virtual const std::vector<ILayer::CPtr> getOutputs() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a constant vector of connections for specific layer.
|
|
* If the layer is missing, returns empty vector.
|
|
* @param layerId layer index
|
|
* @return Vector of connections
|
|
*/
|
|
virtual const std::vector<Connection> getLayerConnections(idx_t layerId) const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a network name.
|
|
* @return Network name
|
|
*/
|
|
virtual const std::string& getName() const noexcept = 0;
|
|
|
|
/**
|
|
* @brief Returns a network context
|
|
* @return const reference to Context
|
|
*/
|
|
virtual const Context& getContext() const noexcept = 0;
|
|
};
|
|
|
|
} // namespace InferenceEngine
|
|
|
|
#include <details/ie_inetwork_iterator.hpp>
|