namespace ov::op::v0

Overview

namespace v0 {

// namespaces

namespace ov::op::v0::lstm_cell;

// structs

template <class TShape>
struct NegativeToZero;

// 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, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const Concat \* op,
    const std::vector<T>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const CTCGreedyDecoder \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const DepthToSpace \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const DetectionOutput \* op,
    const std::vector<TShape>& input_shapes
    );

template <class T, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const FakeQuantize \* op,
    const std::vector<T>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const Interpolate \* op,
    const std::vector<TShape>& input_shapes,
    const ITensorAccessor& tensor_accessor
    );

template <class T>
std::vector<result_shape_t<T>> shape_infer(
    const LSTMCell \* op,
    const std::vector<T>& input_shapes
    );

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

template <class T, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const MatMul \* op,
    const std::vector<T>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const PriorBoxClustered \*const op,
    const std::vector<TShape>& input_shapes,
    const ITensorAccessor& ta = make_tensor_accessor()
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const PriorBox \*const op,
    const std::vector<TShape>& input_shapes,
    const ITensorAccessor& ta = make_tensor_accessor()
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const Proposal \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const PSROIPooling \* op,
    const std::vector<TShape>& input_shapes
    );

template <class T, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const Range \* op,
    const std::vector<T>& input_shapes,
    const ITensorAccessor& tensor_accessor = make_tensor_accessor()
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const RegionYolo \* op,
    const std::vector<TShape>& input_shapes
    );

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

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

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

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const ROIPooling \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const ShapeOf \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const ShuffleChannels \* op,
    const std::vector<TShape>& input_shapes
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const ov::op::v0::SpaceToDepth \* op,
    const std::vector<TShape>& input_shapes
    );

template <class T, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const Squeeze \* op,
    const std::vector<T>& input_shapes,
    const ITensorAccessor& ta = make_tensor_accessor()
    );

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const Tile \* op,
    const std::vector<TShape>& input_shapes,
    const ITensorAccessor& tensor_accessor = make_tensor_accessor()
    );

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

template <class TShape, class TRShape = result_shape_t<TShape>>
std::vector<TRShape> shape_infer(
    const Unsqueeze \* op,
    const std::vector<TShape>& input_shapes,
    const ITensorAccessor& tensor_accessor = make_tensor_accessor()
    );

} // namespace v0

Detailed Documentation

Global Functions

template <class T, class TRShape = result_shape_t<T>>
std::vector<TRShape> shape_infer(
    const Squeeze \* op,
    const std::vector<T>& input_shapes,
    const ITensorAccessor& ta = make_tensor_accessor()
    )

Do Squeeze shape inference.

Parameters:

T	Type of input/output shapes.
op	Squeeze operator pointer.
input_shapes	Squeeze input shapes.
ta	Tensor accessor to constant data.