namespace ov::op::v0

Overview

namespace v0 {

// classes

class Abs;
class Acos;
class Asin;
class Atan;
class BatchNormInference;
class CTCGreedyDecoder;
class Ceiling;
class Clamp;
class Concat;
class Constant;
class Convert;
class Cos;
class Cosh;
class CumSum;
class DepthToSpace;
class DetectionOutput;
class Elu;
class Erf;
class Exp;
class FakeQuantize;
class Floor;
class GRN;
class Gelu;
class HardSigmoid;
class Interpolate;
class LRN;
class LSTMCell;
class LSTMSequence;
class Log;
class MVN;
class MatMul;
class Negative;
class NormalizeL2;
class PRelu;
class PSROIPooling;
class Parameter;
class PriorBox;
class PriorBoxClustered;
class Proposal;
class RNNCell;
class ROIPooling;
class Range;
class RegionYolo;
class Relu;
class ReorgYolo;
class Result;
class ReverseSequence;
class Selu;
class ShapeOf;
class ShuffleChannels;
class Sigmoid;
class Sign;
class Sin;
class Sinh;
class SpaceToDepth;
class Sqrt;
class SquaredDifference;
class Squeeze;
class Tan;
class Tanh;
class TensorIterator;
class Tile;
class Unsqueeze;
class Xor;

// global functions

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

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

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

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

template <class T>
void shape_infer(
    const Interpolate \* 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 LSTMCell \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes
    );

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

template <class OpType, class ShapeType>
void infer_prop_shape(
    const OpType \* op,
    const std::vector<ShapeType>& input_shapes,
    std::vector<ShapeType>& output_shapes
    );

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

template <class T>
void shape_infer(
    const Range \* 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 RegionYolo \* op,
    const std::vector<T>& input_shapes,
    std::vector<T>& output_shapes
    );

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

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

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

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

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

template <class T>
void shape_infer(
    const Squeeze \* 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>
std::vector<T> shape_infer(
    const Tile \* op,
    const std::vector<T>& input_shapes,
    const std::map<size_t, std::reference_wrapper<const ov::Tensor>>& constant_data = {}
    );

template <class TOp>
void check_unsqueeze_axes_rank(
    const TOp \* op,
    const Rank& rank
    );

template <class T>
void shape_infer(
    const Unsqueeze \* 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 v0

Detailed Documentation

Global Functions

template <class T>
void shape_infer(
    const Squeeze \* 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 Squeeze shape inference.

Parameters:

T

Type of input/output shapes.

op

Squeeze operator pointer.

input_shapes

Squeeze input shapes.

output_shapes

Output shapes result of squeeze shape inference.

constant_data

Map of constant data.