ONE - On-device Neural Engine
Loading...
Searching...
No Matches
Public Member Functions
onert::ir::OperationValidator Class Reference

#include <OperationValidator.h>

Collaboration diagram for onert::ir::OperationValidator:
Collaboration graph
[legend]

Public Member Functions

 OperationValidator (void)=delete
 
 OperationValidator (const Graph &graph)
 
void operator() ()
 
void visit (const operation::AddN &node) override
 
void visit (const operation::ArgMinMax &node) override
 
void visit (const operation::BatchMatMul &node) override
 
void visit (const operation::BatchToSpaceND &node) override
 
void visit (const operation::BinaryArithmetic &node) override
 
void visit (const operation::BroadcastTo &node) override
 
void visit (const operation::Comparison &node) override
 
void visit (const operation::Concat &node) override
 
void visit (const operation::Conv2D &node) override
 
void visit (const operation::DepthToSpace &node) override
 
void visit (const operation::DepthwiseConv2D &node) override
 
void visit (const operation::DetectionPostProcess &node) override
 
void visit (const operation::DynamicUpdateSlice &node) override
 
void visit (const operation::ElementwiseActivation &node) override
 
void visit (const operation::ElementwiseBinary &node) override
 
void visit (const operation::ElementwiseUnary &node) override
 
void visit (const operation::EmbeddingLookup &node) override
 
void visit (const operation::ExpandDims &node) override
 
void visit (const operation::Fill &node) override
 
void visit (const operation::Gather &node) override
 
void visit (const operation::HashtableLookup &node) override
 
void visit (const operation::Pack &node) override
 
void visit (const operation::Pad &node) override
 
void visit (const operation::Rank &node) override
 
void visit (const operation::ResizeBilinear &node) override
 
void visit (const operation::Reverse &node) override
 
void visit (const operation::RoPE &node) override
 
void visit (const operation::Select &node) override
 
void visit (const operation::Shape &node) override
 
void visit (const operation::Slice &node) override
 
void visit (const operation::Softmax &node) override
 
void visit (const operation::SpaceToBatchND &node) override
 
void visit (const operation::SpaceToDepth &node) override
 
void visit (const operation::Split &node) override
 
void visit (const operation::SquaredDifference &node) override
 
void visit (const operation::StatelessRandomUniform &node) override
 
void visit (const operation::StridedSlice &node) override
 
void visit (const operation::TopKV2 &node) override
 
void visit (const operation::Transpose &node) override
 
void visit (const operation::TransposeConv &node) override
 
void visit (const operation::Unpack &node) override
 
void visit (const operation::While &node) override
 
- Public Member Functions inherited from onert::ir::OperationVisitor
virtual ~OperationVisitor ()=default
 

Detailed Description

Definition at line 33 of file OperationValidator.h.

Constructor & Destructor Documentation

◆ OperationValidator() [1/2]

onert::ir::OperationValidator::OperationValidator ( void  )
delete

◆ OperationValidator() [2/2]

onert::ir::OperationValidator::OperationValidator ( const Graph &  graph)

Definition at line 32 of file OperationValidator.cc.

33 : _operations{graph.operations()}, _operands{graph.operands()}
34{
35}

Member Function Documentation

◆ operator()()

void onert::ir::OperationValidator::operator() ( )

Definition at line 37 of file OperationValidator.cc.

38{
39 _operations.iterate([&](const OperationIndex &, const IOperation &node) { node.accept(*this); });
40}
onert::util::ObjectManager::iterate
void iterate(const std::function< void(const Index &, const Object &)> &fn) const
Iterate over the container with given function.
Definition ObjectManager.h:184
onert::ir::OperationIndex
::onert::util::Index< uint32_t, OperationIndexTag > OperationIndex
Definition Index.h:30

References onert::ir::IOperation::accept(), and onert::util::ObjectManager< Index, Object >::iterate().

◆ visit() [1/42]

void onert::ir::OperationValidator::visit ( const operation::AddN &  node)
override

Definition at line 86 of file OperationValidator.cc.

87{
88 const auto output_index(node.getOutputs().at(0));
89
90 int size = node.getInputs().size();
91 for (int i = 0; i < size; i++)
92 {
93 const auto input_index(node.getInputs().at(i));
94 OP_REQUIRES(isValidType(input_index, {DataType::FLOAT32, DataType::INT32}));
95 OP_REQUIRES(isSameType(input_index, output_index));
96 }
97}
OP_REQUIRES
#define OP_REQUIRES(EXP)
Definition ShapeValidator.cc:25
size
int32_t size[5]
Definition Slice.cpp:35

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), OP_REQUIRES, onert::ir::OperandIndexSequence::size(), and size.

◆ visit() [2/42]

void onert::ir::OperationValidator::visit ( const operation::ArgMinMax &  node)
override

Definition at line 99 of file OperationValidator.cc.

100{
101 const auto input_index(node.getInputs().at(operation::ArgMinMax::Input::INPUT));
102 const auto axis_index(node.getInputs().at(operation::ArgMinMax::Input::AXIS));
103 const auto output_index(node.getOutputs().at(0));
104 const auto output_type = node.param().output_type;
105
106 OP_REQUIRES(isValidType(input_index, {DataType::FLOAT32, DataType::INT32, DataType::UINT8,
107 DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
108 OP_REQUIRES(isValidType(axis_index, {DataType::INT32, DataType::INT64}));
109 OP_REQUIRES(isValidType(output_index, {DataType::INT32, DataType::INT64}));
110 OP_REQUIRES(isValidType(output_index, output_type));
111}
validate_onnx2circle.output_type
output_type
Definition validate_onnx2circle.py:129

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::ArgMinMax::AXIS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ArgMinMax::INPUT, OP_REQUIRES, onert::ir::operation::ArgMinMax::Param::output_type, and onert::ir::operation::ArgMinMax::param().

◆ visit() [3/42]

void onert::ir::OperationValidator::visit ( const operation::BatchMatMul &  node)
override

Definition at line 113 of file OperationValidator.cc.

114{
115 const auto lhs_index(node.getInputs().at(operation::BatchMatMul::Input::LHS));
116 const auto rhs_index(node.getInputs().at(operation::BatchMatMul::Input::RHS));
117 const auto output_index(node.getOutputs().at(0));
118
119 // RHS can be constant, but LHS is not constant
120 // If one of inputs is constant, it must be RHS
121 // If two inputs are constant, BatchMatMul is optimized into constant by compiler
122 OP_REQUIRES(!isConstant(lhs_index));
123
124 // Allow hybrid quantization (lhs: float / rhs: qint8 / out: float)
125 OP_REQUIRES(isValidType(
126 lhs_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
127 OP_REQUIRES(isSameType(lhs_index, rhs_index) ||
128 ((operandType(lhs_index) == DataType::FLOAT32) &&
129 (operandType(rhs_index) == DataType::QUANT_INT8_ASYMM)));
130 OP_REQUIRES(isSameType(lhs_index, output_index));
131}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::BatchMatMul::LHS, OP_REQUIRES, and onert::ir::operation::BatchMatMul::RHS.

◆ visit() [4/42]

void onert::ir::OperationValidator::visit ( const operation::BatchToSpaceND &  node)
override

Definition at line 133 of file OperationValidator.cc.

134{
135 const auto input_index{node.getInputs().at(operation::BatchToSpaceND::Input::INPUT)};
136 const auto output_index{node.getOutputs().at(0)};
137
138 OP_REQUIRES(isSameType(input_index, output_index));
139}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::BatchToSpaceND::INPUT, and OP_REQUIRES.

◆ visit() [5/42]

void onert::ir::OperationValidator::visit ( const operation::BinaryArithmetic &  node)
override

Definition at line 141 of file OperationValidator.cc.

142{
143 const auto output_index{node.getOutputs().at(0)};
144 const auto lhs_index{node.getInputs().at(operation::BinaryArithmetic::Input::LHS)};
145 const auto rhs_index{node.getInputs().at(operation::BinaryArithmetic::Input::RHS)};
146
147 OP_REQUIRES(isSameType(lhs_index, rhs_index));
148 OP_REQUIRES(isSameType(lhs_index, output_index));
149}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::BinaryArithmetic::LHS, OP_REQUIRES, and onert::ir::operation::BinaryArithmetic::RHS.

◆ visit() [6/42]

void onert::ir::OperationValidator::visit ( const operation::BroadcastTo &  node)
override

Definition at line 151 of file OperationValidator.cc.

152{
153 const auto input_index(node.getInputs().at(operation::BroadcastTo::Input::INPUT));
154 const auto shape_index(node.getInputs().at(operation::BroadcastTo::Input::SHAPE));
155 const auto output_index(node.getOutputs().at(0));
156
157 OP_REQUIRES(isSameType(input_index, output_index));
158 OP_REQUIRES(isValidType(shape_index, {DataType::INT32, DataType::INT64}));
159}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::BroadcastTo::INPUT, OP_REQUIRES, and onert::ir::operation::BroadcastTo::SHAPE.

◆ visit() [7/42]

void onert::ir::OperationValidator::visit ( const operation::Comparison &  node)
override

Definition at line 161 of file OperationValidator.cc.

162{
163 const auto output_index{node.getOutputs().at(0)};
164
165 const auto lhs_index{node.getInputs().at(operation::Comparison::Input::INPUT0)};
166 const auto rhs_index{node.getInputs().at(operation::Comparison::Input::INPUT1)};
167
168 OP_REQUIRES(isSameType(lhs_index, rhs_index));
169 OP_REQUIRES(isValidType(output_index, DataType::BOOL8));
170}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Comparison::INPUT0, onert::ir::operation::Comparison::INPUT1, and OP_REQUIRES.

◆ visit() [8/42]

void onert::ir::OperationValidator::visit ( const operation::Concat &  node)
override

Definition at line 172 of file OperationValidator.cc.

173{
174 const auto output_index{node.getOutputs().at(0)};
175
176 for (auto &&input_index : node.getInputs())
177 {
178 OP_REQUIRES(isSameType(input_index, output_index));
179
180 // Int8 and Int16 quantization requires same scale and zero point
181 if (isValidType(output_index, DataType::QUANT_INT8_ASYMM) ||
182 isValidType(output_index, DataType::QUANT_INT16_SYMM))
183 {
184 OP_REQUIRES(isSameQuantParam(input_index, output_index));
185 }
186 }
187}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), and OP_REQUIRES.

◆ visit() [9/42]

void onert::ir::OperationValidator::visit ( const operation::Conv2D &  node)
override

Definition at line 189 of file OperationValidator.cc.

190{
191 const auto input_index{node.getInputs().at(operation::Conv2D::Input::INPUT)};
192 const auto kernel_index{node.getInputs().at(operation::Conv2D::Input::KERNEL)};
193 const auto output_index{node.getOutputs().at(0)};
194
195 uint32_t stride_horizontal = node.param().stride.horizontal;
196 uint32_t stride_vertical = node.param().stride.vertical;
197 uint32_t dilation_width = node.param().dilation.width_factor;
198 uint32_t dilation_height = node.param().dilation.height_factor;
199
200 OP_REQUIRES((stride_horizontal > 0) && (stride_vertical > 0));
201 OP_REQUIRES((dilation_width > 0) && (dilation_height > 0));
202 OP_REQUIRES(isSameType(input_index, output_index));
203
204 if (isConstant(kernel_index) && operandType(kernel_index) == DataType::QUANT_INT8_ASYMM)
205 {
206 for (const auto zeropoint : _operands.at(kernel_index).typeInfo().zero_points())
207 OP_REQUIRES(zeropoint == 0);
208 }
209}

References onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), onert::ir::operation::Conv2D::Param::dilation, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::Dilation::height_factor, onert::ir::Stride::horizontal, onert::ir::operation::Conv2D::INPUT, onert::ir::operation::Conv2D::KERNEL, OP_REQUIRES, onert::ir::operation::Conv2D::param(), onert::ir::operation::Conv2D::Param::stride, onert::ir::Stride::vertical, and onert::ir::Dilation::width_factor.

◆ visit() [10/42]

void onert::ir::OperationValidator::visit ( const operation::DepthToSpace &  node)
override

Definition at line 211 of file OperationValidator.cc.

212{
213 const auto input_index{node.getInputs().at(operation::DepthToSpace::Input::INPUT)};
214 const auto output_index{node.getOutputs().at(0)};
215
216 int32_t block_size = node.param().block_size;
217
218 OP_REQUIRES(isValidType(input_index, {DataType::FLOAT32, DataType::INT32, DataType::INT64,
219 DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
220 OP_REQUIRES(isSameType(input_index, output_index));
221
222 OP_REQUIRES(block_size > 0);
223}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::DepthToSpace::Param::block_size, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::DepthToSpace::INPUT, OP_REQUIRES, and onert::ir::operation::DepthToSpace::param().

◆ visit() [11/42]

void onert::ir::OperationValidator::visit ( const operation::DepthwiseConv2D &  node)
override

Definition at line 225 of file OperationValidator.cc.

226{
227 const auto input_index{node.getInputs().at(operation::DepthwiseConv2D::Input::INPUT)};
228 const auto kernel_index{node.getInputs().at(operation::DepthwiseConv2D::Input::KERNEL)};
229 const auto output_index{node.getOutputs().at(0)};
230
231 uint32_t stride_horizontal = node.param().stride.horizontal;
232 uint32_t stride_vertical = node.param().stride.vertical;
233 uint32_t dilation_width = node.param().dilation.width_factor;
234 uint32_t dilation_height = node.param().dilation.height_factor;
235
236 OP_REQUIRES((stride_horizontal > 0) && (stride_vertical > 0));
237 OP_REQUIRES((dilation_width > 0) && (dilation_height > 0));
238 OP_REQUIRES(isSameType(input_index, output_index));
239
240 if (isConstant(kernel_index) && operandType(kernel_index) == DataType::QUANT_INT8_ASYMM)
241 {
242 for (const auto zeropoint : _operands.at(kernel_index).typeInfo().zero_points())
243 OP_REQUIRES(zeropoint == 0);
244 }
245}

References onert::util::ObjectManager< Index, Object >::at(), onert::ir::OperandIndexSequence::at(), onert::ir::operation::DepthwiseConv2D::Param::dilation, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::Dilation::height_factor, onert::ir::Stride::horizontal, onert::ir::operation::DepthwiseConv2D::INPUT, onert::ir::operation::DepthwiseConv2D::KERNEL, OP_REQUIRES, onert::ir::operation::DepthwiseConv2D::param(), onert::ir::operation::DepthwiseConv2D::Param::stride, onert::ir::Stride::vertical, and onert::ir::Dilation::width_factor.

◆ visit() [12/42]

void onert::ir::OperationValidator::visit ( const operation::DetectionPostProcess &  node)
override

Definition at line 247 of file OperationValidator.cc.

248{
249 const auto &param = node.param();
250
251 // FIXME: number of classes should be 1 for now.
252 OP_REQUIRES(param.num_classes == 1);
253}

References OP_REQUIRES, and onert::ir::operation::DetectionPostProcess::param().

◆ visit() [13/42]

void onert::ir::OperationValidator::visit ( const operation::DynamicUpdateSlice &  node)
override

Definition at line 255 of file OperationValidator.cc.

256{
257 const auto operand_index{node.getInputs().at(operation::DynamicUpdateSlice::Input::OPERAND)};
258 const auto update_index{node.getInputs().at(operation::DynamicUpdateSlice::Input::UPDATE)};
259 const auto indices_index{node.getInputs().at(operation::DynamicUpdateSlice::Input::INDICES)};
260 const auto output_index{node.getOutputs().at(0)};
261
262 OP_REQUIRES(isSameType(operand_index, update_index));
263 OP_REQUIRES(isSameType(operand_index, output_index));
264 OP_REQUIRES(operandType(indices_index) == DataType::INT32 ||
265 operandType(indices_index) == DataType::INT64);
266}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::DynamicUpdateSlice::INDICES, OP_REQUIRES, onert::ir::operation::DynamicUpdateSlice::OPERAND, and onert::ir::operation::DynamicUpdateSlice::UPDATE.

◆ visit() [14/42]

void onert::ir::OperationValidator::visit ( const operation::ElementwiseActivation &  node)
override

Definition at line 268 of file OperationValidator.cc.

269{
270 const auto output_index{node.getOutputs().at(0)};
271 const auto input_index{node.getInputs().at(0)};
272
273 // Check if I/O types match
274 OP_REQUIRES(isSameType(output_index, input_index));
275
276 switch (node.param().op_type)
277 {
278 case operation::ElementwiseActivation::Type::ELU:
279 case operation::ElementwiseActivation::Type::GELU:
280 OP_REQUIRES(isValidType(input_index, DataType::FLOAT32));
281 break;
282 case operation::ElementwiseActivation::Type::LEAKY_RELU:
283 OP_REQUIRES(
284 isValidType(input_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM,
285 DataType::QUANT_INT8_ASYMM, DataType::QUANT_INT16_SYMM}));
286 break;
287 case operation::ElementwiseActivation::Type::LOGISTIC:
288 OP_REQUIRES(
289 isValidType(input_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM,
290 DataType::QUANT_INT8_ASYMM, DataType::QUANT_INT16_SYMM}));
291 break;
292 case operation::ElementwiseActivation::Type::RELU:
293 OP_REQUIRES(isValidType(
294 input_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
295 break;
296 case operation::ElementwiseActivation::Type::TANH:
297 OP_REQUIRES(
298 isValidType(input_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM,
299 DataType::QUANT_INT8_ASYMM, DataType::QUANT_INT16_SYMM}));
300 break;
301 }
302}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::ElementwiseActivation::ELU, onert::ir::operation::ElementwiseActivation::GELU, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ElementwiseActivation::LEAKY_RELU, onert::ir::operation::ElementwiseActivation::LOGISTIC, OP_REQUIRES, onert::ir::operation::ElementwiseActivation::Param::op_type, onert::ir::operation::ElementwiseActivation::param(), onert::ir::operation::ElementwiseActivation::RELU, and onert::ir::operation::ElementwiseActivation::TANH.

◆ visit() [15/42]

void onert::ir::OperationValidator::visit ( const operation::ElementwiseBinary &  node)
override

Definition at line 304 of file OperationValidator.cc.

305{
306 const auto output_index{node.getOutputs().at(0)};
307 const auto lhs_index{node.getInputs().at(operation::ElementwiseBinary::Input::LHS)};
308 const auto rhs_index{node.getInputs().at(operation::ElementwiseBinary::Input::RHS)};
309
310 OP_REQUIRES(isSameType(lhs_index, rhs_index));
311 OP_REQUIRES(isSameType(lhs_index, output_index));
312
313 const auto op_type = node.param().op_type;
314 if (op_type == operation::ElementwiseBinary::ElementwiseBinaryType::LOGICAL_AND ||
315 op_type == operation::ElementwiseBinary::ElementwiseBinaryType::LOGICAL_OR)
316 {
317 OP_REQUIRES(isValidType(lhs_index, DataType::BOOL8));
318 }
319}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ElementwiseBinary::LHS, onert::ir::operation::ElementwiseBinary::LOGICAL_AND, onert::ir::operation::ElementwiseBinary::LOGICAL_OR, OP_REQUIRES, onert::ir::operation::ElementwiseBinary::Param::op_type, onert::ir::operation::ElementwiseBinary::param(), and onert::ir::operation::ElementwiseBinary::RHS.

◆ visit() [16/42]

void onert::ir::OperationValidator::visit ( const operation::ElementwiseUnary &  node)
override

Definition at line 321 of file OperationValidator.cc.

322{
323 const auto output_index{node.getOutputs().at(0)};
324 const auto input_index{node.getInputs().at(operation::ElementwiseUnary::Input::INPUT)};
325
326 // Check if I/O types match
327 if (node.param().op_type == operation::ElementwiseUnary::Type::DEQUANTIZE)
328 {
329 // NNAPI allow QUANT_INT8_SYMM type input
330 OP_REQUIRES(isValidType(input_index, {DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_SYMM,
331 DataType::QUANT_INT8_ASYMM, DataType::QUANT_INT16_SYMM}));
332 OP_REQUIRES(isValidType(output_index, DataType::FLOAT32));
333 }
334 else if (node.param().op_type == operation::ElementwiseUnary::Type::QUANTIZE)
335 {
336 OP_REQUIRES(isValidType(
337 input_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
338 OP_REQUIRES(isValidType(output_index, {DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM,
339 DataType::QUANT_INT16_SYMM}));
340 }
341 else if (node.param().op_type == operation::ElementwiseUnary::Type::FLOOR)
342 {
343 OP_REQUIRES(isValidType(input_index, DataType::FLOAT32));
344 OP_REQUIRES(isSameType(output_index, input_index));
345 }
346 else if (node.param().op_type != operation::ElementwiseUnary::Type::CAST)
347 {
348 OP_REQUIRES(isSameType(output_index, input_index));
349 }
350}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::ElementwiseUnary::CAST, onert::ir::operation::ElementwiseUnary::DEQUANTIZE, onert::ir::operation::ElementwiseUnary::FLOOR, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ElementwiseUnary::INPUT, OP_REQUIRES, onert::ir::operation::ElementwiseUnary::Param::op_type, onert::ir::operation::ElementwiseUnary::param(), and onert::ir::operation::ElementwiseUnary::QUANTIZE.

◆ visit() [17/42]

void onert::ir::OperationValidator::visit ( const operation::EmbeddingLookup &  node)
override

Definition at line 352 of file OperationValidator.cc.

353{
354 const auto lookups_index{node.getInputs().at(operation::EmbeddingLookup::Input::LOOKUPS)};
355 const auto values_index{node.getInputs().at(operation::EmbeddingLookup::Input::VALUES)};
356 const auto output_index{node.getOutputs().at(0)};
357
358 OP_REQUIRES(isValidType(lookups_index, DataType::INT32));
359
360 // TFLite: Allow hybrid type - value table & output
361 // NNAPI: Require same value table and output type
362 OP_REQUIRES(
363 isSameType(values_index, output_index) ||
364 (isValidType(output_index, DataType::FLOAT32) &&
365 (isValidType(values_index, {DataType::QUANT_INT8_ASYMM, DataType::QUANT_INT8_SYMM}))));
366}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::EmbeddingLookup::LOOKUPS, OP_REQUIRES, and onert::ir::operation::EmbeddingLookup::VALUES.

◆ visit() [18/42]

void onert::ir::OperationValidator::visit ( const operation::ExpandDims &  node)
override

Definition at line 368 of file OperationValidator.cc.

369{
370 const auto output_index{node.getOutputs().at(0)};
371 const auto input_index{node.getInputs().at(operation::ExpandDims::Input::INPUT)};
372 const auto axis_index{node.getInputs().at(operation::ExpandDims::Input::AXIS)};
373
374 OP_REQUIRES(isSameType(output_index, input_index));
375 OP_REQUIRES(isValidType(axis_index, {DataType::INT32, DataType::INT64}));
376}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::ExpandDims::AXIS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::ExpandDims::INPUT, and OP_REQUIRES.

◆ visit() [19/42]

void onert::ir::OperationValidator::visit ( const operation::Fill &  node)
override

Definition at line 378 of file OperationValidator.cc.

379{
380 const auto output_index{node.getOutputs().at(0)};
381 const auto input_index{node.getInputs().at(operation::Fill::Input::SHAPE)};
382 const auto value_index{node.getInputs().at(operation::Fill::Input::VALUE)};
383
384 OP_REQUIRES(isSameType(output_index, value_index));
385 OP_REQUIRES(isValidType(input_index, {DataType::INT32, DataType::INT64}));
386 OP_REQUIRES(isValidType(output_index,
387 {DataType::FLOAT32, DataType::INT32, DataType::INT64, DataType::BOOL8}));
388}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), OP_REQUIRES, onert::ir::operation::Fill::SHAPE, and onert::ir::operation::Fill::VALUE.

◆ visit() [20/42]

void onert::ir::OperationValidator::visit ( const operation::Gather &  node)
override

Definition at line 390 of file OperationValidator.cc.

391{
392 const auto output_index{node.getOutputs().at(0)};
393 const auto input_index{node.getInputs().at(operation::Gather::INPUT)};
394 const auto indices_index{node.getInputs().at(operation::Gather::INDICES)};
395
396 const auto input_type = operandType(input_index);
397 if (input_type == DataType::QUANT_GGML_Q4_0 || input_type == DataType::QUANT_GGML_Q8_0)
398 OP_REQUIRES(isValidType(output_index, {DataType::FLOAT32}));
399 else
400 OP_REQUIRES(isSameType(output_index, input_index));
401
402 OP_REQUIRES(isValidType(indices_index, {DataType::INT32, DataType::INT64}));
403}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Gather::INDICES, onert::ir::operation::Gather::INPUT, and OP_REQUIRES.

◆ visit() [21/42]

void onert::ir::OperationValidator::visit ( const operation::HashtableLookup &  node)
override

Definition at line 405 of file OperationValidator.cc.

406{
407 const auto hits_index{node.getOutputs().at(operation::HashtableLookup::Output::HITS)};
408 const auto lookups_index{node.getInputs().at(operation::HashtableLookup::Input::LOOKUPS)};
409 const auto keys_index{node.getInputs().at(operation::HashtableLookup::Input::KEYS)};
410
411 OP_REQUIRES(isValidType(lookups_index, DataType::INT32));
412 OP_REQUIRES(isValidType(keys_index, DataType::INT32));
413 OP_REQUIRES(isValidType(hits_index, DataType::QUANT_UINT8_ASYMM));
414}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::HashtableLookup::HITS, onert::ir::operation::HashtableLookup::KEYS, onert::ir::operation::HashtableLookup::LOOKUPS, and OP_REQUIRES.

◆ visit() [22/42]

void onert::ir::OperationValidator::visit ( const operation::Pack &  node)
override

Definition at line 416 of file OperationValidator.cc.

417{
418 const auto num{node.param().num};
419
420 OP_REQUIRES(num == static_cast<int32_t>(node.getInputs().size()));
421}

References onert::ir::Operation::getInputs(), onert::ir::operation::Pack::Param::num, OP_REQUIRES, onert::ir::operation::Pack::param(), and onert::ir::OperandIndexSequence::size().

◆ visit() [23/42]

void onert::ir::OperationValidator::visit ( const operation::Pad &  node)
override

Definition at line 423 of file OperationValidator.cc.

424{
425 const auto output_index{node.getOutputs().at(0)};
426 const auto input_index{node.getInputs().at(operation::Pad::Input::INPUT)};
427 const auto pad_index{node.getInputs().at(operation::Pad::Input::PAD)};
428 bool isQuantType =
429 isValidType(output_index, {DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM});
430 bool isPadV2 = node.getInputs().size() == 3 ? true : false;
431
432 OP_REQUIRES(isValidType(pad_index, DataType::INT32));
433 OP_REQUIRES(isSameType(input_index, output_index));
434
435 if (isQuantType)
436 OP_REQUIRES(isSameQuantParam(input_index, output_index));
437
438 if (isPadV2)
439 {
440 const auto value_index{node.getInputs().at(operation::Pad::Input::VALUE)};
441 const bool cond_same = isSameType(input_index, value_index);
442 const bool cond_same_quant = (!isQuantType || isSameQuantParam(input_index, value_index));
443 const auto input_t = operandType(input_index);
444 const auto value_t = operandType(value_index);
445 // NNAPI accepts this case. scale and zeroPoint are assumed to be the same as in input0.
446 const bool cond_quant8 =
447 ((input_t == DataType::QUANT_UINT8_ASYMM || input_t == DataType::QUANT_INT8_ASYMM) &&
448 value_t == DataType::INT32);
449 OP_REQUIRES((cond_same && cond_same_quant) || cond_quant8);
450 }
451}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Pad::INPUT, OP_REQUIRES, onert::ir::operation::Pad::PAD, onert::ir::OperandIndexSequence::size(), and onert::ir::operation::Pad::VALUE.

◆ visit() [24/42]

void onert::ir::OperationValidator::visit ( const operation::Rank &  node)
override

Definition at line 453 of file OperationValidator.cc.

454{
455 const auto output_index{node.getOutputs().at(0)};
456
457 OP_REQUIRES(isValidType(output_index, DataType::INT32));
458}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getOutputs(), and OP_REQUIRES.

◆ visit() [25/42]

void onert::ir::OperationValidator::visit ( const operation::ResizeBilinear &  node)
override

Definition at line 460 of file OperationValidator.cc.

461{
462 auto align_corners = node.param().align_corners;
463 auto half_pixel_centers = node.param().half_pixel_centers;
464
465 OP_REQUIRES(!align_corners || !half_pixel_centers);
466}

References onert::ir::operation::ResizeBilinear::Param::align_corners, onert::ir::operation::ResizeBilinear::Param::half_pixel_centers, OP_REQUIRES, and onert::ir::operation::ResizeBilinear::param().

◆ visit() [26/42]

void onert::ir::OperationValidator::visit ( const operation::Reverse &  node)
override

Definition at line 468 of file OperationValidator.cc.

469{
470 const auto output_index{node.getOutputs().at(0)};
471 const auto input_index{node.getInputs().at(operation::Reverse::Input::INPUT)};
472 const auto axis_index{node.getInputs().at(operation::Reverse::Input::AXIS)};
473
474 OP_REQUIRES(isValidType(axis_index, DataType::INT32));
475 OP_REQUIRES(isSameType(output_index, input_index));
476}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::Reverse::AXIS, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Reverse::INPUT, and OP_REQUIRES.

◆ visit() [27/42]

void onert::ir::OperationValidator::visit ( const operation::RoPE &  node)
override

Definition at line 478 of file OperationValidator.cc.

479{
480 const auto input_index{node.getInputs().at(operation::RoPE::Input::INPUT)};
481 const auto sin_index{node.getInputs().at(operation::RoPE::Input::SIN_TABLE)};
482 const auto cos_index{node.getInputs().at(operation::RoPE::Input::COS_TABLE)};
483 const auto output_index{node.getOutputs().at(operation::RoPE::Output::OUTPUT)};
484
485 OP_REQUIRES(isValidType(input_index, DataType::FLOAT32));
486 OP_REQUIRES(isValidType(sin_index, DataType::FLOAT32));
487 OP_REQUIRES(isValidType(cos_index, DataType::FLOAT32));
488 OP_REQUIRES(isSameType(input_index, output_index));
489}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::RoPE::COS_TABLE, onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::RoPE::INPUT, OP_REQUIRES, onert::ir::operation::RoPE::OUTPUT, and onert::ir::operation::RoPE::SIN_TABLE.

◆ visit() [28/42]

void onert::ir::OperationValidator::visit ( const operation::Select &  node)
override

Definition at line 491 of file OperationValidator.cc.

492{
493 const auto condition_index{node.getInputs().at(operation::Select::Input::CONDITION)};
494 const auto input_true_index{node.getInputs().at(operation::Select::Input::INPUT_TRUE)};
495 const auto input_false_index{node.getInputs().at(operation::Select::Input::INPUT_FALSE)};
496
497 OP_REQUIRES(isValidType(condition_index, DataType::BOOL8));
498 OP_REQUIRES(isSameType(input_true_index, input_false_index));
499}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::Select::CONDITION, onert::ir::Operation::getInputs(), onert::ir::operation::Select::INPUT_FALSE, onert::ir::operation::Select::INPUT_TRUE, and OP_REQUIRES.

◆ visit() [29/42]

void onert::ir::OperationValidator::visit ( const operation::Shape &  node)
override

Definition at line 501 of file OperationValidator.cc.

502{
503 const auto output_index{node.getOutputs().at(0)};
504
505 OP_REQUIRES(isValidType(output_index, {DataType::UINT32, DataType::INT32, DataType::INT64}));
506}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getOutputs(), and OP_REQUIRES.

◆ visit() [30/42]

void onert::ir::OperationValidator::visit ( const operation::Slice &  node)
override

Definition at line 508 of file OperationValidator.cc.

509{
510 const auto begins_index{node.getInputs().at(operation::Slice::BEGINS)};
511 const auto sizes_index{node.getInputs().at(operation::Slice::SIZES)};
512
513 OP_REQUIRES(isValidType(begins_index, {DataType::INT32, DataType::INT64}));
514 OP_REQUIRES(isSameType(begins_index, sizes_index));
515}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::Slice::BEGINS, onert::ir::Operation::getInputs(), OP_REQUIRES, and onert::ir::operation::Slice::SIZES.

◆ visit() [31/42]

void onert::ir::OperationValidator::visit ( const operation::Softmax &  node)
override

Definition at line 517 of file OperationValidator.cc.

518{
519 const auto output_index{node.getOutputs().at(0)};
520 const auto input_index{node.getInputs().at(operation::Softmax::INPUT)};
521
522 OP_REQUIRES(isSameType(input_index, output_index));
523 OP_REQUIRES(isValidType(
524 output_index, {DataType::FLOAT32, DataType::QUANT_UINT8_ASYMM, DataType::QUANT_INT8_ASYMM}));
525}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Softmax::INPUT, and OP_REQUIRES.

◆ visit() [32/42]

void onert::ir::OperationValidator::visit ( const operation::SpaceToBatchND &  node)
override

Definition at line 527 of file OperationValidator.cc.

528{
529 const auto block_size_index{node.getInputs().at(operation::SpaceToBatchND::Input::BLOCK_SIZE)};
530 const auto paddings_index{node.getInputs().at(operation::SpaceToBatchND::Input::PADDINGS)};
531
532 // Non-constant block_size and padding is not implemented yet
533 OP_REQUIRES(isConstant(block_size_index));
534 OP_REQUIRES(isConstant(paddings_index));
535}

References onert::ir::OperandIndexSequence::at(), onert::ir::operation::SpaceToBatchND::BLOCK_SIZE, onert::ir::Operation::getInputs(), OP_REQUIRES, and onert::ir::operation::SpaceToBatchND::PADDINGS.

◆ visit() [33/42]

void onert::ir::OperationValidator::visit ( const operation::SpaceToDepth &  node)
override

Definition at line 537 of file OperationValidator.cc.

538{
539 const auto block_size = node.param().block_size;
540 OP_REQUIRES(block_size >= 1);
541}

References onert::ir::operation::SpaceToDepth::Param::block_size, OP_REQUIRES, and onert::ir::operation::SpaceToDepth::param().

◆ visit() [34/42]

void onert::ir::OperationValidator::visit ( const operation::Split &  node)
override

Definition at line 543 of file OperationValidator.cc.

544{
545 const auto num_splits = node.param().num_splits;
546
547 OP_REQUIRES(num_splits > 0 && num_splits <= 0xFFFF);
548 OP_REQUIRES(node.getOutputs().size() == static_cast<uint32_t>(num_splits));
549}

References onert::ir::Operation::getOutputs(), onert::ir::operation::Split::Param::num_splits, OP_REQUIRES, onert::ir::operation::Split::param(), and onert::ir::OperandIndexSequence::size().

◆ visit() [35/42]

void onert::ir::OperationValidator::visit ( const operation::SquaredDifference &  node)
override

Definition at line 551 of file OperationValidator.cc.

552{
553 const auto output_index{node.getOutputs().at(0)};
554 const auto lhs_index{node.getInputs().at(operation::SquaredDifference::Input::LHS)};
555 const auto rhs_index{node.getInputs().at(operation::SquaredDifference::Input::RHS)};
556
557 OP_REQUIRES(isSameType(output_index, lhs_index));
558 OP_REQUIRES(isSameType(lhs_index, rhs_index));
559}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::SquaredDifference::LHS, OP_REQUIRES, and onert::ir::operation::SquaredDifference::RHS.

◆ visit() [36/42]

void onert::ir::OperationValidator::visit ( const operation::StatelessRandomUniform &  node)
override

Definition at line 561 of file OperationValidator.cc.

562{
563 const auto output_index{node.getOutputs().at(0)};
564 const auto shape_index{node.getInputs().at(operation::StatelessRandomUniform::Input::SHAPE)};
565 const auto seed_index{node.getInputs().at(operation::StatelessRandomUniform::Input::SEED)};
566
567 OP_REQUIRES(isValidType(output_index, DataType::FLOAT32));
568 OP_REQUIRES(isValidType(shape_index, DataType::INT32));
569 OP_REQUIRES(isValidType(seed_index, DataType::INT32));
570}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), OP_REQUIRES, onert::ir::operation::StatelessRandomUniform::SEED, and onert::ir::operation::StatelessRandomUniform::SHAPE.

◆ visit() [37/42]

void onert::ir::OperationValidator::visit ( const operation::StridedSlice &  node)
override

Definition at line 572 of file OperationValidator.cc.

573{
574 const auto output_index{node.getOutputs().at(0)};
575 const auto input_index{node.getInputs().at(operation::StridedSlice::Input::INPUT)};
576
577 OP_REQUIRES(isSameType(output_index, input_index));
578
579 if (isValidType(output_index, DataType::QUANT_INT16_SYMM))
580 {
581 OP_REQUIRES(isSameQuantParam(input_index, output_index));
582 }
583}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::StridedSlice::INPUT, and OP_REQUIRES.

◆ visit() [38/42]

void onert::ir::OperationValidator::visit ( const operation::TopKV2 &  node)
override

Definition at line 585 of file OperationValidator.cc.

586{
587 const auto output_value_index{node.getOutputs().at(0)};
588 const auto input_index{node.getInputs().at(operation::TopKV2::Input::INPUT)};
589
590 OP_REQUIRES(isSameType(output_value_index, input_index));
591 OP_REQUIRES(node.param().k >= 0);
592}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::TopKV2::INPUT, onert::ir::operation::TopKV2::Param::k, OP_REQUIRES, and onert::ir::operation::TopKV2::param().

◆ visit() [39/42]

void onert::ir::OperationValidator::visit ( const operation::Transpose &  node)
override

Definition at line 594 of file OperationValidator.cc.

595{
596 const auto output_index{node.getOutputs().at(0)};
597 const auto input_index{node.getInputs().at(operation::Transpose::Input::INPUT)};
598
599 OP_REQUIRES(isSameType(output_index, input_index));
600}

References onert::ir::OperandIndexSequence::at(), onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), onert::ir::operation::Transpose::INPUT, and OP_REQUIRES.

◆ visit() [40/42]

void onert::ir::OperationValidator::visit ( const operation::TransposeConv &  node)
override

Definition at line 602 of file OperationValidator.cc.

603{
604 OP_REQUIRES((node.param().padding.type == PaddingType::SAME) ||
605 (node.param().padding.type == PaddingType::VALID));
606}

References OP_REQUIRES, onert::ir::operation::TransposeConv::Param::padding, onert::ir::operation::TransposeConv::param(), onert::ir::SAME, onert::ir::Padding::type, and onert::ir::VALID.

◆ visit() [41/42]

void onert::ir::OperationValidator::visit ( const operation::Unpack &  node)
override

Definition at line 608 of file OperationValidator.cc.

609{
610 const auto num{node.param().num};
611 OP_REQUIRES(num == static_cast<int32_t>(node.getOutputs().size()));
612}

References onert::ir::Operation::getOutputs(), onert::ir::operation::Unpack::Param::num, OP_REQUIRES, onert::ir::operation::Unpack::param(), and onert::ir::OperandIndexSequence::size().

◆ visit() [42/42]

void onert::ir::OperationValidator::visit ( const operation::While &  node)
override

Definition at line 614 of file OperationValidator.cc.

615{
616 OP_REQUIRES(node.getInputs().size() == node.getOutputs().size());
617}

References onert::ir::Operation::getInputs(), onert::ir::Operation::getOutputs(), OP_REQUIRES, and onert::ir::OperandIndexSequence::size().

The documentation for this class was generated from the following files: