namespace ov::op::v1

Overview

namespace v1 {

// namespaces

namespace ov::op::v1::utils;
    namespace ov::op::v1::utils::one_hot;

// classes

class Add;
class AvgPool;
class BatchToSpace;
class BinaryConvolution;
class Broadcast;
class ConvertLike;
class Convolution;
class ConvolutionBackpropData;
class DeformableConvolution;
class DeformablePSROIPooling;
class Divide;
class Equal;
class FloorMod;
class Gather;
class GatherTree;
class Greater;
class GreaterEqual;
class GroupConvolution;
class GroupConvolutionBackpropData;
class Less;
class LessEqual;
class LogicalAnd;
class LogicalNot;
class LogicalOr;
class LogicalXor;
class MaxPool;
class Maximum;
class Minimum;
class Mod;
class Multiply;
class NonMaxSuppression;
class NotEqual;
class OneHot;
class Pad;
class Power;
class ReduceLogicalAnd;
class ReduceLogicalOr;
class ReduceMax;
class ReduceMean;
class ReduceMin;
class ReduceProd;
class ReduceSum;
class Reshape;
class Reverse;
class Select;
class Softmax;
class SpaceToBatch;
class Split;
class StridedSlice;
class Subtract;
class TopK;
class Transpose;
class VariadicSplit;

// global functions

template <class TShape, class TContainer>
std::vector<TShape> shape_infer(
    const AvgPool \* op,
    const std::vector<TShape>& input_shapes,
    TContainer& pads_begin,
    TContainer& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const BatchToSpace \* op,
    const std::vector<TShape>& input_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
void shape_infer(
    const ov::op::v1::BatchToSpace \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class T>
void shape_infer(
    const ov::op::v1::Broadcast \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const ConvolutionBackpropData \* op,
    const std::vector<TShape>& input_shapes,
    CoordinateDiff& pads_begin,
    CoordinateDiff& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TFrowardConv, class TShape, class TContainer>
std::vector<TShape> shape_infer(
    const TFrowardConv \* op,
    const std::vector<TShape>& input_shapes,
    TContainer& pads_begin,
    TContainer& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const DeformableConvolution \* op,
    const std::vector<TShape>& input_shapes,
    CoordinateDiff& pads_begin,
    CoordinateDiff& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const DeformablePSROIPooling \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape>
void shape_infer(
    const DeformablePSROIPooling \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const GatherTree \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape>
void shape_infer(
    const GatherTree \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const GroupConvolutionBackpropData \* op,
    const std::vector<TShape>& input_shapes,
    CoordinateDiff& pads_begin,
    CoordinateDiff& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const GroupConvolution \* op,
    const std::vector<TShape>& input_shapes,
    CoordinateDiff& pads_begin,
    CoordinateDiff& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape, class TContainer>
std::vector<TShape> shape_infer(
    const MaxPool \* op,
    const std::vector<TShape>& input_shapes,
    TContainer& pads_begin,
    TContainer& pads_end,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

void resolve_axis(OneHot \* op);

template <class T>
void shape_infer(
    const OneHot \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const Pad \* op,
    const std::vector<TShape>& input_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
void shape_infer(
    const Pad \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const Reverse \* op,
    const std::vector<TShape>& input_shapes,
    const std::map<size_t, std::reference_wrapper<const ov::Tensor>>& constant_data = {}
    );

template <class TShape>
void shape_infer(
    const Reverse \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes,
    const std::map<size_t, std::reference_wrapper<const ov::Tensor>>& constant_data = {}
    );

template <class T>
void shape_infer(
    const Select \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes
    );

template <class TShape>
std::vector<TShape> shape_infer(
    const SpaceToBatch \* op,
    const std::vector<TShape>& input_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class TShape>
void shape_infer(
    const SpaceToBatch \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <typename T>
void shape_infer(
    const Split \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

template <class T>
void shape_infer(
    const StridedSlice \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

template <typename T>
void shape_infer(
    const TopK \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    );

template <class T>
T calc_output_shape(
    const Transpose \*const op,
    const T& input_shape,
    std::vector<int64_t>& axes_order
    );

template <class T>
void shape_infer(
    const Transpose \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

template <typename T>
void shape_infer(
    const VariadicSplit \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    );

} // namespace v1

Detailed Documentation

Global Functions

template <class TShape>
std::vector<TShape> shape_infer(
    const Reverse \* op,
    const std::vector<TShape>& input_shapes,
    const std::map<size_t, std::reference_wrapper<const ov::Tensor>>& constant_data = {}
    )

Reverse shape inference.

Parameters:

TShape	Type of shape.
op	Pointer to Reverse operator.
input_shapes	Input shapes of Reverse.
constant_data	Map of constant data. Default empty.

Returns:

Vector of output shapes with one shape.

template <class TShape>
void shape_infer(
    const Reverse \* op,
    const std::vector<TShape>& input_shapes,
    std::vector<TShape>& output_shapes,
    const std::map<size_t, std::reference_wrapper<const ov::Tensor>>& constant_data = {}
    )

Reverse shape inference.

Parameters:

TShape	Type of shape.
op	Pointer to Reverse operator.
input_shapes	Input shapes of Reverse.
output_shapes	Output shapes of Reverse
constant_data	Map of constant data. Default empty.

template <typename T>
void shape_infer(
    const Split \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    )

Shape inference for Split V1 operator.

The split operation cause label lost on splitted dimension even if number of splits is one, because in this case split will be removed by transformation (as NOP) and in fact label will be propagated.

Parameters:

T	Type of shape.
op	Split operator pointer.
input_shapes	Split input shapes.
output_shapes	Split output shapes.
constant_data	Map of constant data.

template <typename T>
void shape_infer(
    const TopK \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, HostTensorPtr>& constant_data = {}
    )

TopK shape inference.

Parameters:

TShape	Type of shape.
op	Pointer to TopK operator.
input_shapes	Input shapes of TopK.
output_shapes	Output shapes of TopK
constant_data	Map of constant data. Default empty.

template <class T>
T calc_output_shape(
    const Transpose \*const op,
    const T& input_shape,
    std::vector<int64_t>& axes_order
    )

Calculate transpose output shape.

Parameters:

T	Type of shape
op	Transpose operator pointer.
input_shape	Transpose input shape.
axes_order	Transpose axes order (modified if empty).

Returns:

Output shape

template <class T>
void shape_infer(
    const Transpose \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes,
    const std::map<size_t, std::shared_ptr<ngraph::runtime::HostTensor>>& constant_data = {}
    )

Do transpose inference on input and output shapes.

Parameters:

T	Type of inference shapes.
op	Transpose operator pointer.
input_shapes	Input shapes of transpose.
output_shapes	Output shapes of transpose which be modified by inference.
constant_data	Map of constant data.