Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 6a5e5e8b7e56f927d70ced3203d6e16df3fdd189 / . / src / backends / reference / RefLayerSupport.cpp
blob: 299503ddc6c337c3875f33e9dd92ebc3341544fa [file] [log] [blame]
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]1//
2// Copyright © 2017 Arm Ltd. All rights reserved.
David Beckecb56cd2018-09-05 12:52:57 +0100[diff] [blame]3// SPDX-License-Identifier: MIT
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]4//
5
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]6#include "RefLayerSupport.hpp"
David Beck3e9e1152018-10-17 14:17:50 +0100[diff] [blame]7#include "RefBackendId.hpp"
David Beck3cc9a622018-10-12 10:38:31 +0100[diff] [blame]8
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]9#include <armnn/Types.hpp>
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]10#include <armnn/Descriptors.hpp>
Matteo Martincighc601aa62019-10-29 15:03:22 +0000[diff] [blame]11#include <armnn/BackendRegistry.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]12
Matteo Martincighe011d202019-11-28 11:35:47 +0000[diff] [blame]13#include <armnnUtils/DataLayoutIndexed.hpp>
14
15#include <InternalTypes.hpp>
16#include <LayerSupportCommon.hpp>
17
Derek Lambertif674aa02019-08-01 15:56:25 +0100[diff] [blame]18#include <backendsCommon/LayerSupportRules.hpp>
Matteo Martincighe011d202019-11-28 11:35:47 +0000[diff] [blame]19
Matteo Martincighe011d202019-11-28 11:35:47 +0000[diff] [blame]20#include <boost/cast.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]21#include <boost/core/ignore_unused.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]22
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]23#include <vector>
24#include <algorithm>
25#include <array>
26
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]27using namespace boost;
28
29namespace armnn
30{
31
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]32namespace
33{
34
35template<typename Float32Func, typename Uint8Func, typename ... Params>
36bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
37 DataType dataType,
38 Float32Func floatFuncPtr,
39 Uint8Func uint8FuncPtr,
40 Params&&... params)
41{
42 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
43 dataType,
44 &FalseFunc<Params...>,
45 floatFuncPtr,
46 uint8FuncPtr,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]47 &FalseFunc<Params...>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]48 &FalseFunc<Params...>,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]49 std::forward<Params>(params)...);
50}
51
52} // anonymous namespace
53
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]54namespace
55{
56
57std::string CreateIncorrectDimensionsErrorMsg(unsigned int expected,
58 unsigned int actual,
59 std::string& layerStr,
60 std::string& tensorName)
61{
62 std::string errorMsg = "Reference " + layerStr + ": Expected " + std::to_string(expected) + " dimensions but got" +
63 " " + std::to_string(actual) + " dimensions instead, for the '" + tensorName + "' tensor.";
64
65 return errorMsg;
66}
67
68} // anonymous namespace
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]69
Sadik Armagan9199e582019-09-05 17:35:31 +0100[diff] [blame]70bool RefLayerSupport::IsAbsSupported(const TensorInfo& input, const TensorInfo& output,
71 Optional<std::string&> reasonIfUnsupported) const
72{
73 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]74 std::array<DataType,4> supportedTypes =
Sadik Armagan9199e582019-09-05 17:35:31 +0100[diff] [blame]75 {
76 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]77 DataType::Float16,
Sadik Armagan9199e582019-09-05 17:35:31 +0100[diff] [blame]78 DataType::QuantisedAsymm8,
79 DataType::QuantisedSymm16
80 };
81
82 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
83 "Reference abs: input type not supported");
84
85 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
86 "Reference abs: output type not supported");
87
88 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
89 "Reference abs: input and output types not matching");
90
91 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
92 "Reference abs: input and output shapes have different number of total elements");
93
94 return supported;
95}
96
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]97bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
98 const TensorInfo& output,
99 const ActivationDescriptor& descriptor,
100 Optional<std::string&> reasonIfUnsupported) const
101{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]102 bool supported = true;
103
104 // Define supported types.
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]105 std::array<DataType,4> supportedTypes = {
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]106 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]107 DataType::Float16,
Teresa Charlin18515e22019-04-24 10:17:46 +0100[diff] [blame]108 DataType::QuantisedAsymm8,
109 DataType::QuantisedSymm16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]110 };
111
112 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
113 "Reference activation: input type not supported.");
114
115 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
116 "Reference activation: output type not supported.");
117
118 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
119 "Reference activation: input and output types mismatched.");
120
121 supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
122 "Reference activation: input and output shapes are of different rank.");
123
124
125 struct ActivationFunctionSupported : public Rule
126 {
127 ActivationFunctionSupported(const ActivationDescriptor& desc)
128 {
129 switch(desc.m_Function)
130 {
131 case ActivationFunction::Abs:
132 case ActivationFunction::BoundedReLu:
133 case ActivationFunction::LeakyReLu:
134 case ActivationFunction::Linear:
135 case ActivationFunction::ReLu:
136 case ActivationFunction::Sigmoid:
137 case ActivationFunction::SoftReLu:
138 case ActivationFunction::Sqrt:
139 case ActivationFunction::Square:
140 case ActivationFunction::TanH:
141 {
142 m_Res = true;
143 break;
144 }
145 default:
146 {
147 m_Res = false;
148 break;
149 }
150 }
151 }
152 };
153
154 // Function is supported
155 supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
156 "Reference activation: function not supported.");
157
158 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]159}
160
161bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
162 const TensorInfo& input1,
163 const TensorInfo& output,
164 Optional<std::string&> reasonIfUnsupported) const
165{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]166 bool supported = true;
167
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]168 std::array<DataType,4> supportedTypes = {
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]169 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]170 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]171 DataType::QuantisedAsymm8,
172 DataType::QuantisedSymm16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]173 };
174
175 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
176 "Reference addition: input 0 is not a supported type.");
177
178 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
179 "Reference addition: input 1 is not a supported type.");
180
181 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
182 "Reference addition: output is not a supported type.");
183
184 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
185 "Reference addition: input 0 and Input 1 types are mismatched");
186
187 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
188 "Reference addition: input and output types are mismatched");
189
190 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
191 "Reference addition: shapes are not suitable for implicit broadcast.");
192
193 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]194}
195
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]196bool RefLayerSupport::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output,
197 const armnn::ArgMinMaxDescriptor &descriptor,
198 armnn::Optional<std::string &> reasonIfUnsupported) const
199{
200 ignore_unused(descriptor);
201
Francis Murtagh1939df52019-11-13 15:21:09 +0000[diff] [blame]202 std::array<DataType, 4> supportedTypes =
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]203 {
204 DataType::Float32,
205 DataType::QuantisedAsymm8,
Francis Murtagh1939df52019-11-13 15:21:09 +0000[diff] [blame]206 DataType::QuantisedSymm16,
207 DataType::Signed32
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]208 };
209
210 bool supported = true;
211
212 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
213 "Reference ArgMinMax: input is not a supported type.");
214 supported &= CheckSupportRule(TypeIs(output, DataType::Signed32), reasonIfUnsupported,
215 "Reference ArgMinMax: output type not supported");
216
217 return supported;
218}
219
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]220bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
221 const TensorInfo& output,
222 const TensorInfo& mean,
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]223 const TensorInfo& variance,
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]224 const TensorInfo& beta,
225 const TensorInfo& gamma,
226 const BatchNormalizationDescriptor& descriptor,
227 Optional<std::string&> reasonIfUnsupported) const
228{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]229 ignore_unused(descriptor);
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]230
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]231 std::array<DataType, 4> supportedTypes =
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]232 {
233 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]234 DataType::Float16,
Matteo Martincighf5507132019-06-04 10:59:47 +0100[diff] [blame]235 DataType::QuantisedAsymm8,
236 DataType::QuantisedSymm16
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]237 };
238
239 bool supported = true;
240
241 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
242 "Reference batch normalization: input is not a supported type.");
243
244 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
245 "Reference batch normalization: output is not a supported type.");
246
247 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
248 "Reference batch normalization: input and output types are mismatched");
249
250 supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
251 "Reference batch normalization: mean is not a supported type.");
252
253 supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
254 "Reference batch normalization: variance is not a supported type.");
255
256 supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
257 "Reference batch normalization: beta is not a supported type.");
258
259 supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
260 "Reference batch normalization: gamma is not a supported type.");
261
262 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]263}
264
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]265bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
266 const TensorInfo& output,
267 const BatchToSpaceNdDescriptor& descriptor,
268 Optional<std::string&> reasonIfUnsupported) const
269{
270 ignore_unused(descriptor);
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]271
272 bool supported = true;
273
274 std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
275 std::string inputTensorStr = "input";
276 std::string outputTensorStr = "output";
277
278 // Define supported types.
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]279 std::array<DataType,4> supportedTypes =
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]280 {
281 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]282 DataType::Float16,
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]283 DataType::QuantisedAsymm8,
284 DataType::QuantisedSymm16
285 };
286
287 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
288 "Reference BatchToSpaceNd: input type not supported.");
289
290 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
291 "Reference BatchToSpaceNd: output type not supported.");
292
293 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
294 "Reference BatchToSpaceNd: input and output types mismatched.");
295
296 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
297 reasonIfUnsupported,
298 CreateIncorrectDimensionsErrorMsg(4,
299 output.GetNumDimensions(),
300 batchToSpaceNdLayerStr,
301 outputTensorStr).data());
302
303 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
304 reasonIfUnsupported,
305 CreateIncorrectDimensionsErrorMsg(4,
306 input.GetNumDimensions(),
307 batchToSpaceNdLayerStr,
308 inputTensorStr).data());
309
310 return supported;
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]311}
312
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]313bool RefLayerSupport::IsComparisonSupported(const TensorInfo& input0,
314 const TensorInfo& input1,
315 const TensorInfo& output,
316 const ComparisonDescriptor& descriptor,
317 Optional<std::string&> reasonIfUnsupported) const
318{
319 boost::ignore_unused(descriptor);
320
321 std::array<DataType, 4> supportedInputTypes =
322 {
323 DataType::Float32,
324 DataType::Float16,
325 DataType::QuantisedAsymm8,
326 DataType::QuantisedSymm16
327 };
328
329 bool supported = true;
330 supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
331 "Reference comparison: input 0 is not a supported type");
332
333 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
334 "Reference comparison: input 0 and Input 1 types are mismatched");
335
336 supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
337 "Reference comparison: output is not of type Boolean");
338
339 return supported;
340}
341
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]342bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
343 const TensorInfo& output,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]344 const ConcatDescriptor& descriptor,
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]345 Optional<std::string&> reasonIfUnsupported) const
346{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]347 ignore_unused(descriptor);
348
349 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]350 std::array<DataType,4> supportedTypes =
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]351 {
352 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]353 DataType::Float16,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]354 DataType::QuantisedAsymm8,
355 DataType::QuantisedSymm16
356 };
357
358 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
359 "Reference concatenation: output type not supported");
360 for (const TensorInfo* input : inputs)
361 {
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]362 BOOST_ASSERT(input != nullptr);
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]363 supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
364 "Reference concatenation: input type not supported");
365
366 supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
367 "Reference concatenation: input and output types mismatched.");
368 }
369
370 return supported;
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]371}
372
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]373bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
374 Optional<std::string&> reasonIfUnsupported) const
375{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]376 std::array<DataType,4> supportedTypes =
377 {
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]378 DataType::Float32,
379 DataType::Signed32,
380 DataType::QuantisedAsymm8,
381 DataType::QuantisedSymm16
382 };
383
384 return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
385 "Reference constant: output is not a supported type.");
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]386}
387
388bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
389 const TensorInfo& output,
390 Optional<std::string&> reasonIfUnsupported) const
391{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]392 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
393 input.GetDataType(),
394 &TrueFunc<>,
395 &FalseInputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]396 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]397 &FalseFuncI32<>,
398 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]399 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
400 output.GetDataType(),
401 &FalseOutputFuncF16<>,
402 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]403 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]404 &FalseFuncI32<>,
405 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]406}
407
408bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
409 const TensorInfo& output,
410 Optional<std::string&> reasonIfUnsupported) const
411{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]412 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
413 input.GetDataType(),
414 &FalseInputFuncF16<>,
415 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]416 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]417 &FalseFuncI32<>,
418 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]419 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
420 output.GetDataType(),
421 &TrueFunc<>,
422 &FalseOutputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]423 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]424 &FalseFuncI32<>,
425 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]426}
427
428bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
429 const TensorInfo& output,
430 const Convolution2dDescriptor& descriptor,
431 const TensorInfo& weights,
432 const Optional<TensorInfo>& biases,
433 Optional<std::string&> reasonIfUnsupported) const
434{
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]435 bool supported = true;
436
437 // Define supported types.
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]438 std::array<DataType,4> supportedTypes =
439 {
440 DataType::Float32,
441 DataType::Float16,
442 DataType::QuantisedAsymm8,
443 DataType::QuantisedSymm16
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]444 };
445
446 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]447 "Reference convolution2d: input is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]448
449 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]450 "Reference convolution2d: output is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]451
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]452 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]453 "Reference convolution2d: input and output types mismatched.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]454
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]455 const DataType inputType = input.GetDataType();
456 if (inputType == DataType::QuantisedAsymm8)
457 {
458 std::array<DataType, 2> supportedWeightTypes =
459 {
460 DataType::QuantisedAsymm8,
461 DataType::QuantizedSymm8PerAxis
462 };
463
464 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
465 "Reference convolution2d: weights type not supported for quantized input.");
466 }
467 else
468 {
469 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
470 "Reference convolution2d: weights is not a supported type.");
471
472 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
473 "Reference convolution2d: input and weights types mismatched.");
474 }
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]475
476 if (biases.has_value())
477 {
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]478 std::array<DataType,3> biasesSupportedTypes =
479 {
480 DataType::Float32,
481 DataType::Float16,
482 DataType::Signed32
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]483 };
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]484
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]485 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
Les Belld7f29082019-05-30 09:08:51 +0100[diff] [blame]486 "Reference convolution2d: biases is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]487 }
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]488 ignore_unused(descriptor);
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]489
490 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]491}
492
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]493bool RefLayerSupport::IsDebugSupported(const TensorInfo& input,
494 const TensorInfo& output,
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]495 Optional<std::string&> reasonIfUnsupported) const
496{
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]497 bool supported = true;
498
Aron Virginas-Tardb1a2832019-11-12 16:15:11 +0000[diff] [blame]499 std::array<DataType, 4> supportedTypes =
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]500 {
Aron Virginas-Tardb1a2832019-11-12 16:15:11 +0000[diff] [blame]501 DataType::Float16,
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]502 DataType::Float32,
503 DataType::QuantisedAsymm8,
504 DataType::QuantisedSymm16
505 };
506
507 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
508 "Reference debug: input type not supported");
509
510 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
511 "Reference debug: output type not supported");
512
513 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
514 "Reference debug: input and output types are mismatched");
515
516 return supported;
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]517}
518
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]519bool RefLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
520 const TensorInfo& output,
521 const DepthToSpaceDescriptor& descriptor,
522 Optional<std::string&> reasonIfUnsupported) const
523{
524 ignore_unused(descriptor);
525 bool supported = true;
526
527 std::array<DataType,4> supportedTypes =
528 {
529 DataType::Float32,
530 DataType::Float16,
531 DataType::QuantisedAsymm8,
532 DataType::QuantisedSymm16
533 };
534
535 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
536 "Reference DepthToSpace: input type not supported");
537
538 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
539 "Reference DepthToSpace: output type not supported");
540
541 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
542 "Reference DepthToSpace: input and output types are mismatched");
543
544 return supported;
545}
546
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]547bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
548 const TensorInfo& output,
549 const DepthwiseConvolution2dDescriptor& descriptor,
550 const TensorInfo& weights,
551 const Optional<TensorInfo>& biases,
552 Optional<std::string&> reasonIfUnsupported) const
553{
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]554 bool supported = true;
555
556 // Define supported types.
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]557 std::array<DataType,4> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]558 {
559 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]560 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]561 DataType::QuantisedAsymm8,
562 DataType::QuantisedSymm16
563 };
564
565 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
566 "Reference DepthwiseConvolution2d: input is not a supported type.");
567
568 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
569 "Reference DepthwiseConvolution2d: output is not a supported type.");
570
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]571 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
572 "Reference DepthwiseConvolution2d: input and output types mismatched.");
573
Teresa Charlind8df0262019-11-11 12:28:15 +0000[diff] [blame]574 const DataType inputType = input.GetDataType();
575 if (inputType == DataType::QuantisedAsymm8)
576 {
577 std::array<DataType, 2> supportedWeightTypes =
578 {
579 DataType::QuantisedAsymm8,
580 DataType::QuantizedSymm8PerAxis
581 };
582
583 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
584 "Reference convolution2d: weights type not supported for quantized input.");
585 }
586 else
587 {
588 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
589 "Reference DepthwiseConvolution2d: weights is not a supported type.");
590
591 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
592 "Reference DepthwiseConvolution2d: input and weights types mismatched.");
593 }
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]594
595 if (biases.has_value())
596 {
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]597 std::array<DataType,3> biasesSupportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]598 {
599 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]600 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]601 DataType::Signed32
602 };
603 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
604 "Reference DepthwiseConvolution2d: biases is not a supported type.");
605 }
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]606 ignore_unused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]607
608 return supported;
609
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]610}
611
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]612bool RefLayerSupport::IsDequantizeSupported(const TensorInfo& input,
613 const TensorInfo& output,
614 Optional<std::string&> reasonIfUnsupported) const
615{
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]616 bool supported = true;
617
618 std::array<DataType,2> supportedInputTypes = {
619 DataType::QuantisedAsymm8,
620 DataType::QuantisedSymm16
621 };
622
623 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
624 "Reference dequantize: input type not supported.");
625
Jan Eilersf7107932019-11-01 11:09:36 +0000[diff] [blame]626 std::array<DataType,2> supportedOutputTypes = {
627 DataType::Float32,
628 DataType::Float16
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]629 };
630
631 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
632 "Reference dequantize: output type not supported.");
633
634 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
635 "Reference dequantize: input and output shapes have different num total elements.");
636
637 return supported;
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]638}
639
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame^]640bool RefLayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
641 const TensorInfo& scores,
642 const TensorInfo& anchors,
643 const TensorInfo& detectionBoxes,
644 const TensorInfo& detectionClasses,
645 const TensorInfo& detectionScores,
646 const TensorInfo& numDetections,
647 const DetectionPostProcessDescriptor& descriptor,
648 Optional<std::string&> reasonIfUnsupported) const
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame]649{
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]650 bool supported = true;
651
Mike Kelly4992c342019-08-14 11:33:11 +0100[diff] [blame]652 std::array<DataType,3> supportedInputTypes =
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]653 {
654 DataType::Float32,
655 DataType::QuantisedAsymm8,
656 DataType::QuantisedSymm16
657 };
658
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame^]659 supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]660 "Reference DetectionPostProcess: input 0 is not a supported type.");
661
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame^]662 supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]663 "Reference DetectionPostProcess: input 1 is not a supported type.");
664
665 return supported;
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame]666}
667
Pablo Tellof0bd6832019-04-26 17:58:13 +0100[diff] [blame]668bool RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
669 const TensorInfo& output,
670 const DepthwiseConvolution2dDescriptor& descriptor,
671 const TensorInfo& weights,
672 const Optional<TensorInfo>& biases,
673 Optional<std::string&> reasonIfUnsupported) const
674{
Aron Virginas-Taraece4ed2019-06-14 17:00:09 +0100[diff] [blame]675 return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
Pablo Tellof0bd6832019-04-26 17:58:13 +0100[diff] [blame]676}
677
Aron Virginas-Taraece4ed2019-06-14 17:00:09 +0100[diff] [blame]678bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]679 const TensorInfo& input1,
680 const TensorInfo& output,
681 Optional<std::string&> reasonIfUnsupported) const
682{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]683 bool supported = true;
684
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]685 std::array<DataType,4> supportedTypes = {
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]686 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]687 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]688 DataType::QuantisedAsymm8,
689 DataType::QuantisedSymm16
690 };
691
692 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
693 "Reference division: input 0 is not a supported type.");
694
695 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
696 "Reference division: input 1 is not a supported type.");
697
698 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
699 "Reference division: output is not a supported type.");
700
701 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
702 "Reference division: input 0 and Input 1 types are mismatched");
703
704 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
705 "Reference division: input and output types are mismatched");
706
707 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
708 "Reference division: shapes are not suitable for implicit broadcast.");
709
710 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]711}
712
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]713bool RefLayerSupport::IsEqualSupported(const TensorInfo& input0,
714 const TensorInfo& input1,
715 const TensorInfo& output,
716 Optional<std::string&> reasonIfUnsupported) const
717{
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]718 return IsComparisonSupported(input0,
719 input1,
720 output,
721 ComparisonDescriptor(ComparisonOperation::Equal),
722 reasonIfUnsupported);
FrancisMurtagh30cdfca2018-12-18 12:57:35 +0000[diff] [blame]723}
724
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]725bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
726 const FakeQuantizationDescriptor& descriptor,
727 Optional<std::string&> reasonIfUnsupported) const
728{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]729 ignore_unused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]730 bool supported = true;
731
732 std::array<DataType,1> supportedTypes =
733 {
734 DataType::Float32
735 };
736
737 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
738 "Reference fake quantization: input type not supported.");
739
740 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]741}
742
743bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
744 const TensorInfo& output,
745 Optional<std::string&> reasonIfUnsupported) const
746{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]747 ignore_unused(output);
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]748 bool supported = true;
749
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]750 std::array<DataType,3> supportedTypes =
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]751 {
James Conroyb40d7102019-06-04 12:32:09 +0100[diff] [blame]752 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]753 DataType::Float16,
James Conroyb40d7102019-06-04 12:32:09 +0100[diff] [blame]754 DataType::QuantisedSymm16
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]755 };
756
757 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
758 "Reference Floor: input type not supported.");
759
760 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
761 "Reference Floor: output type not supported.");
762
763 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]764}
765
766bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
767 const TensorInfo& output,
768 const TensorInfo& weights,
769 const TensorInfo& biases,
770 const FullyConnectedDescriptor& descriptor,
771 Optional<std::string&> reasonIfUnsupported) const
772{
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]773 bool supported = true;
774
775 // Define supported types.
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]776 std::array<DataType,4> supportedTypes =
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]777 {
778 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]779 DataType::Float16,
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]780 DataType::QuantisedAsymm8,
781 DataType::QuantisedSymm16
782 };
783
784 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
785 "Reference Fully Connected: input type not supported.");
786
787 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
788 "Reference Fully Connected: output type not supported.");
789
790 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
791 "Reference Fully Connected: input and output types mismatched.");
792
793 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
794 "Reference Fully Connected: weights type not supported.");
795
796 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
797 "Reference Fully Connected: input and weight types mismatched.");
798
799 if (descriptor.m_BiasEnabled)
800 {
801 // Defined supported types for bias
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]802 std::array<DataType, 3>
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]803 supportedBiasTypes =
804 {
805 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]806 DataType::Float16,
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]807 DataType::Signed32
808 };
809
810 supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
811 "Reference Fully Connected: bias type not supported.");
812
813 supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
814 "Reference Fully Connected: bias and weight types mismatch.");
815
816 supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
817 "Reference Fully Connected: bias type inferred from weights is incompatible.");
818
819 }
820
821 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]822}
823
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]824bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
825 const armnn::TensorInfo& input1,
826 const armnn::TensorInfo& output,
827 armnn::Optional<std::string&> reasonIfUnsupported) const
828{
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]829 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]830 std::array<DataType,4> supportedTypes =
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]831 {
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]832 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]833 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]834 DataType::QuantisedAsymm8,
835 DataType::QuantisedSymm16
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]836 };
837
838 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
839 "Reference Gather: input type not supported");
840
841 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
842 "Reference Gather: output type not supported");
843
844 supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
845 "Reference Gather: indices (input1) type not supported");
846
847 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
848 "Reference Gather: input and output types not matching");
849
850 return supported;
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]851}
852
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]853bool RefLayerSupport::IsGreaterSupported(const TensorInfo& input0,
854 const TensorInfo& input1,
855 const TensorInfo& output,
856 Optional<std::string&> reasonIfUnsupported) const
857{
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]858 return IsComparisonSupported(input0,
859 input1,
860 output,
861 ComparisonDescriptor(ComparisonOperation::Greater),
862 reasonIfUnsupported);
FrancisMurtagh878f0232018-12-19 10:56:15 +0000[diff] [blame]863}
864
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]865bool RefLayerSupport::IsInputSupported(const TensorInfo& input,
866 Optional<std::string&> reasonIfUnsupported) const
867{
Narumol Prangnawaratb6441e42019-06-04 11:22:00 +0100[diff] [blame]868 return true;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]869}
870
Kevin May09ca49c2019-10-09 12:37:34 +0100[diff] [blame]871bool RefLayerSupport::IsInstanceNormalizationSupported(const TensorInfo& input,
872 const TensorInfo& output,
873 const InstanceNormalizationDescriptor& descriptor,
874 Optional<std::string&> reasonIfUnsupported) const
875{
876 ignore_unused(descriptor);
877 // Define supported types
878 std::array<DataType, 4> supportedTypes =
879 {
880 DataType::Float32,
881 DataType::Float16
882 };
883
884 bool supported = true;
885
886 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
887 "Reference Instance Normalization: input type not supported.");
888
889 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
890 "Reference Instance Normalization: output type not supported.");
891
892 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
893 "Reference Instance Normalization: input and output types mismatched.");
894
895 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
896 "Reference Instance Normalization: input and output shapes have different "
897 "num total elements.");
898
899 return supported;
900}
901
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]902bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
903 const TensorInfo& output,
904 const L2NormalizationDescriptor& descriptor,
905 Optional<std::string&> reasonIfUnsupported) const
906{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]907 ignore_unused(descriptor);
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]908 // Define supported types
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]909 std::array<DataType, 4> supportedTypes =
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]910 {
911 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]912 DataType::Float16,
Ferran Balaguerc6138d82019-06-13 17:23:50 +0100[diff] [blame]913 DataType::QuantisedAsymm8,
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]914 DataType::QuantisedSymm16
915 };
916
917 bool supported = true;
918
919 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
920 "Reference L2normalization: input type not supported.");
921
922 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
923 "Reference L2normalization: output type not supported.");
924
925 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
926 "Reference L2normalization: input and output types mismatched.");
927
928 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
929 "Reference L2normalization: input and output shapes have different "
930 "num total elements.");
931
932 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]933}
934
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]935bool RefLayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
936 const TensorInfo& output,
937 const LogSoftmaxDescriptor& descriptor,
938 Optional<std::string&> reasonIfUnsupported) const
939{
940 ignore_unused(descriptor);
941
942 std::array<DataType, 2> supportedTypes =
943 {
944 DataType::Float32,
945 DataType::Float16
946 };
947
948 bool supported = true;
949 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
950 "Reference LogSoftmax: input type not supported");
951
952 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
953 "Reference LogSoftmax: output type not supported");
954
955 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
956 "Reference LogSoftmax: input and output types do not match");
957
958 return supported;
959}
960
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]961bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
962 const TensorInfo& outputStateIn,
963 const TensorInfo& cellStateIn,
964 const TensorInfo& scratchBuffer,
965 const TensorInfo& outputStateOut,
966 const TensorInfo& cellStateOut,
967 const TensorInfo& output,
968 const LstmDescriptor& descriptor,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]969 const LstmInputParamsInfo& paramsInfo,
970 Optional<std::string&> reasonIfUnsupported) const
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]971{
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]972 ignore_unused(descriptor);
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]973 ignore_unused(paramsInfo);
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]974
975 bool supported = true;
976
977 std::array<DataType,2> supportedTypes = {
Conor Kennedyb9971c92019-05-07 07:14:23 +0100[diff] [blame]978 DataType::Float32,
979 DataType::QuantisedSymm16
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]980 };
981
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]982 // check inputs and outputs
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]983 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
984 "Reference Lstm: input is not a supported type.");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]985 supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
986 "Reference Lstm: input and outputStateIn types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]987 supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
988 "Reference Lstm: input and cellStateIn types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]989 supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
990 "Reference Lstm: input and scratchBuffer types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]991 supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
992 "Reference Lstm: input and outputStateOut types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]993 supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
994 "Reference Lstm: input and cellStateOut types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]995 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
996 "Reference Lstm: input and output types are mismatched");
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]997 // check layer parameters
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]998 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]999 "Reference Lstm: input and InputToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1000 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1001 "Reference Lstm: input and InputToCellWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1002 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1003 "Reference Lstm: input and InputToOutputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1004 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1005 "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1006 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1007 "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1008 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1009 "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1010 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1011 "Reference Lstm: input and ForgetGateBias types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1012 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1013 "Reference Lstm: input and CellBias types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1014 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1015 "Reference Lstm: input and OutputGateBias types are mismatched");
1016 if (!descriptor.m_CifgEnabled)
1017 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1018 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1019 "Reference Lstm: input and InputToInputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1020 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1021 reasonIfUnsupported,
1022 "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1023 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1024 "Reference Lstm: input and InputGateBias types are mismatched");
1025 if (descriptor.m_PeepholeEnabled)
1026 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1027 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1028 reasonIfUnsupported,
1029 "Reference Lstm: input and CellToInputWeights types are mismatched");
1030 }
1031 }
1032 if (descriptor.m_PeepholeEnabled)
1033 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1034 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1035 "Reference Lstm: input and CellToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1036 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1037 "Reference Lstm: input and CellToOutputWeights types are mismatched");
1038 }
1039 if (descriptor.m_ProjectionEnabled)
1040 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1041 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1042 "Reference Lstm: input and mProjectionWeights types are mismatched");
1043 if (paramsInfo.m_ProjectionBias != nullptr)
1044 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1045 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1046 "Reference Lstm: input and ProjectionBias types are mismatched");
1047 }
1048 }
1049 if (descriptor.m_LayerNormEnabled)
1050 {
1051 if (!descriptor.m_CifgEnabled)
1052 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1053 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1054 reasonIfUnsupported,
1055 "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1056 }
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1057 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1058 reasonIfUnsupported,
1059 "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1060 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1061 reasonIfUnsupported,
1062 "Reference Lstm: input and CellLayerNormWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1063 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1064 reasonIfUnsupported,
1065 "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1066 }
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1067
1068 return supported;
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]1069}
1070
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]1071bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
1072 const TensorInfo& input1,
1073 const TensorInfo& output,
1074 Optional<std::string&> reasonIfUnsupported) const
1075{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1076 bool supported = true;
1077
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1078 std::array<DataType,4> supportedTypes = {
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1079 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1080 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1081 DataType::QuantisedAsymm8,
1082 DataType::QuantisedSymm16
1083 };
1084
1085 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1086 "Reference maximum: input 0 is not a supported type.");
1087
1088 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1089 "Reference maximum: input 1 is not a supported type.");
1090
1091 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1092 "Reference maximum: output is not a supported type.");
1093
1094 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1095 "Reference maximum: input 0 and Input 1 types are mismatched");
1096
1097 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1098 "Reference maximum: input and output types are mismatched");
1099
1100 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1101 "Reference maximum: shapes are not suitable for implicit broadcast.");
1102
1103 return supported;
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]1104}
1105
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1106bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
1107 const TensorInfo& output,
1108 const MeanDescriptor& descriptor,
1109 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]1110{
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1111 bool supported = true;
1112 std::string meanLayerStr = "Mean";
1113 std::string outputTensorStr = "output";
1114
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1115 std::array<DataType,4> supportedTypes =
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1116 {
1117 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1118 DataType::Float16,
James Conroyb80775f2019-06-11 11:25:30 +0100[diff] [blame]1119 DataType::QuantisedAsymm8,
1120 DataType::QuantisedSymm16
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1121 };
1122
1123 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1124 "Reference Mean: input type not supported.");
1125
1126 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1127 "Reference Mean: input and output types are mismatched");
1128
1129 if (descriptor.m_KeepDims)
1130 {
1131 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1132 reasonIfUnsupported,
1133 CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1134 output.GetNumDimensions(),
1135 meanLayerStr, outputTensorStr).data());
1136 }
1137 else if (descriptor.m_Axis.empty())
1138 {
1139 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1140 reasonIfUnsupported,
1141 CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1142 meanLayerStr, outputTensorStr).data());
1143 }
1144 else
1145 {
1146 auto outputDim = input.GetNumDimensions() - boost::numeric_cast<unsigned int>(descriptor.m_Axis.size());
1147
1148 if (outputDim > 0)
1149 {
1150 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1151 reasonIfUnsupported,
1152 CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1153 meanLayerStr, outputTensorStr).data());
1154 }
1155 else
1156 {
1157 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1158 reasonIfUnsupported,
1159 CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1160 meanLayerStr, outputTensorStr).data());
1161 }
1162 }
1163
1164 return supported;
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]1165}
1166
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1167bool RefLayerSupport::IsMergerSupported(const std::vector<const TensorInfo*> inputs,
Nikhil Raj8599a412018-11-19 14:51:07 +0000[diff] [blame]1168 const TensorInfo& output,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]1169 const MergerDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1170 Optional<std::string&> reasonIfUnsupported) const
1171{
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]1172 return IsConcatSupported(inputs, output, descriptor, reasonIfUnsupported);
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1173}
1174
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1175bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
1176 const TensorInfo &output,
1177 Optional<std::string &> reasonIfUnsupported) const
1178{
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1179 bool supported = true;
1180
1181 std::array<DataType,5> supportedTypes =
1182 {
1183 DataType::Float32,
1184 DataType::Float16,
1185 DataType::QuantisedAsymm8,
1186 DataType::QuantisedSymm16,
1187 DataType::Boolean
1188 };
1189
1190 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1191 "Reference MemCopy: input type not supported");
1192
1193 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1194 "Reference MemCopy: output type not supported");
1195
1196 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1197 "Reference MemCopy: input and output types are mismatched");
1198
1199 return supported;
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1200}
1201
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]1202bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
1203 const TensorInfo& input1,
1204 const TensorInfo& output,
1205 Optional<std::string&> reasonIfUnsupported) const
1206{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1207 bool supported = true;
1208
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1209 std::array<DataType,4> supportedTypes = {
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1210 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1211 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1212 DataType::QuantisedAsymm8,
1213 DataType::QuantisedSymm16
1214 };
1215
1216 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1217 "Reference minimum: input 0 is not a supported type.");
1218
1219 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1220 "Reference minimum: input 1 is not a supported type.");
1221
1222 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1223 "Reference minimum: output is not a supported type.");
1224
1225 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1226 "Reference minimum: input 0 and Input 1 types are mismatched");
1227
1228 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1229 "Reference minimum: input and output types are mismatched");
1230
1231 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1232 "Reference minimum: shapes are not suitable for implicit broadcast.");
1233
1234 return supported;
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]1235}
1236
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1237bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
1238 const TensorInfo& input1,
1239 const TensorInfo& output,
1240 Optional<std::string&> reasonIfUnsupported) const
1241{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1242 bool supported = true;
1243
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1244 std::array<DataType,4> supportedTypes = {
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1245 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1246 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1247 DataType::QuantisedAsymm8,
1248 DataType::QuantisedSymm16
1249 };
1250
1251 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1252 "Reference multiplication: input 0 is not a supported type.");
1253
1254 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1255 "Reference multiplication: input 1 is not a supported type.");
1256
1257 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1258 "Reference multiplication: output is not a supported type.");
1259
1260 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1261 "Reference multiplication: input 0 and Input 1 types are mismatched");
1262
1263 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1264 "Reference multiplication: input and output types are mismatched");
1265
1266 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1267 "Reference multiplication: shapes are not suitable for implicit broadcast.");
1268
1269 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1270}
1271
1272bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
1273 const TensorInfo& output,
1274 const NormalizationDescriptor& descriptor,
1275 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]1276{
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]1277 ignore_unused(descriptor);
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1278
1279 // Define supported types
Matteo Martincigh6aeb7712019-06-05 17:23:29 +0100[diff] [blame]1280 std::array<DataType, 4> supportedTypes =
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1281 {
1282 DataType::Float16,
1283 DataType::Float32,
Matteo Martincigh6aeb7712019-06-05 17:23:29 +0100[diff] [blame]1284 DataType::QuantisedAsymm8,
1285 DataType::QuantisedSymm16
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1286 };
1287
1288 bool supported = true;
1289
1290 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1291 "Reference normalization: input type not supported.");
1292
1293 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1294 "Reference normalization: output type not supported.");
1295
1296 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1297 "Reference normalization: input and output shapes have different "
1298 "num total elements.");
1299
1300 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1301}
1302
1303bool RefLayerSupport::IsOutputSupported(const TensorInfo& output,
1304 Optional<std::string&> reasonIfUnsupported) const
1305{
Narumol Prangnawaratb6441e42019-06-04 11:22:00 +0100[diff] [blame]1306 return true;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1307}
1308
1309bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
1310 const TensorInfo& output,
1311 const PadDescriptor& descriptor,
1312 Optional<std::string&> reasonIfUnsupported) const
1313{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1314 ignore_unused(descriptor);
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1315 bool supported = true;
1316
1317 // Define supported output and inputs types.
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1318 std::array<DataType,4> supportedTypes =
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1319 {
1320 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1321 DataType::Float16,
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1322 DataType::QuantisedAsymm8,
1323 DataType::QuantisedSymm16
1324 };
1325
1326 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1327 "Reference pad: input is not a supported type.");
1328
1329 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1330 "Reference pad: output is not a supported type.");
1331
1332 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1333 "Reference pad: input and output types are mismatched.");
1334
1335 return supported;
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]1336}
1337
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1338bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
1339 const TensorInfo& output,
1340 const PermuteDescriptor& descriptor,
1341 Optional<std::string&> reasonIfUnsupported) const
1342{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1343 ignore_unused(descriptor);
Narumol Prangnawarat86bb4e12019-07-08 11:36:05 +0100[diff] [blame]1344 bool supported = true;
1345
1346 // Define supported output and inputs types.
1347 std::array<DataType,3> supportedTypes =
1348 {
1349 DataType::Float32,
1350 DataType::QuantisedAsymm8,
1351 DataType::QuantisedSymm16
1352 };
1353
1354 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1355 "Reference permute: input is not a supported type.");
1356
1357 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1358 "Reference permute: output is not a supported type.");
1359
1360 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1361 "Reference permute: input and output types are mismatched.");
1362
1363 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1364}
1365
1366bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
1367 const TensorInfo& output,
1368 const Pooling2dDescriptor& descriptor,
1369 Optional<std::string&> reasonIfUnsupported) const
1370{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1371 ignore_unused(descriptor);
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1372 bool supported = true;
1373
1374 // Define supported output and inputs types.
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1375 std::array<DataType,4> supportedTypes =
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1376 {
1377 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1378 DataType::Float16,
Teresa Charlin0434df62019-06-06 13:40:35 +0100[diff] [blame]1379 DataType::QuantisedAsymm8,
1380 DataType::QuantisedSymm16
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1381 };
1382
1383 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1384 "Reference poolind2d: input is not a supported type.");
1385
1386 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1387 "Reference poolind2d: output is not a supported type.");
1388
1389 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1390 "Reference poolind2d: input and output types are mismatched.");
1391
1392 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1393}
1394
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]1395bool RefLayerSupport::IsQuantizeSupported(const TensorInfo& input,
1396 const TensorInfo& output,
1397 Optional<std::string&> reasonIfUnsupported) const
1398{
1399 bool supported = true;
1400
1401 // Define supported output types.
Sadik Armagan1a816302019-07-29 17:16:40 +0100[diff] [blame]1402 std::array<DataType,1> supportedInputTypes = {
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]1403 DataType::Float32,
1404 };
1405
1406 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1407 "Reference quantize: input type not supported.");
1408
1409 // Define supported output types.
1410 std::array<DataType,2> supportedOutputTypes = {
1411 DataType::QuantisedAsymm8,
1412 DataType::QuantisedSymm16
1413 };
1414 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1415 "Reference quantize: output type not supported.");
1416
1417 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1418 "Reference quantize: input and output shapes have different num total elements.");
1419
1420 return supported;
1421}
1422
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1423bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1424 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1425 Optional<std::string&> reasonIfUnsupported) const
1426{
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1427 ignore_unused(descriptor);
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1428 // Define supported output types.
Narumol Prangnawarat0718ee92019-09-13 16:53:38 +0100[diff] [blame]1429 std::array<DataType,5> supportedOutputTypes =
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1430 {
1431 DataType::Float32,
1432 DataType::Float16,
Narumol Prangnawarat0718ee92019-09-13 16:53:38 +0100[diff] [blame]1433 DataType::Signed32,
Nina Drozd8ed4b8c2019-05-29 10:41:04 +0100[diff] [blame]1434 DataType::QuantisedAsymm8,
1435 DataType::QuantisedSymm16
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1436 };
1437 return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1438 "Reference reshape: input type not supported.");
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1439}
1440
1441bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
Sadik Armaganc625f002018-12-17 11:32:16 +0000[diff] [blame]1442 const TensorInfo& output,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1443 Optional<std::string&> reasonIfUnsupported) const
1444{
Ellen Norris-Thompson3cb85f32019-06-17 11:32:49 +0100[diff] [blame]1445 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1446 std::array<DataType,4> supportedTypes =
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1447 {
1448 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1449 DataType::Float16,
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1450 DataType::QuantisedAsymm8,
1451 DataType::QuantisedSymm16
1452 };
Ellen Norris-Thompson3cb85f32019-06-17 11:32:49 +0100[diff] [blame]1453
1454 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1455 "Reference ResizeBilinear: input type not supported");
1456
1457 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1458 "Reference ResizeBilinear: output type not supported");
1459
1460 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1461 "Reference ResizeBilinear: input and output types not matching");
1462
1463 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1464}
1465
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1466bool RefLayerSupport::IsResizeSupported(const TensorInfo& input,
1467 const TensorInfo& output,
1468 const ResizeDescriptor& descriptor,
1469 Optional<std::string&> reasonIfUnsupported) const
1470{
1471 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1472 std::array<DataType,4> supportedTypes =
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1473 {
1474 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1475 DataType::Float16,
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1476 DataType::QuantisedAsymm8,
1477 DataType::QuantisedSymm16
1478 };
1479
1480 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1481 "Reference Resize: input type not supported");
1482
1483 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1484 "Reference Resize: output type not supported");
1485
1486 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1487 "Reference Resize: input and output types not matching");
1488
1489 return supported;
1490}
1491
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1492bool RefLayerSupport::IsRsqrtSupported(const TensorInfo& input,
1493 const TensorInfo& output,
1494 Optional<std::string&> reasonIfUnsupported) const
1495{
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]1496 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1497 std::array<DataType,4> supportedTypes =
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]1498 {
1499 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1500 DataType::Float16,
nikraj0124d73212019-06-14 14:20:40 +0100[diff] [blame]1501 DataType::QuantisedAsymm8,
1502 DataType::QuantisedSymm16
nikraj010421e7f2019-06-14 09:40:34 +0100[diff] [blame]1503 };
1504
1505 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1506 "Reference rsqrt: input type not supported");
1507
1508 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1509 "Reference rsqrt: output type not supported");
1510
1511 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1512 "Reference rsqrt: input and output types not matching");
1513
1514 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1515 "Reference Rsqrt: input and output shapes have different number of total elements");
1516
1517 return supported;
Mohamed Nour Abouelseouda1d3c6a2018-12-27 12:39:16 +0000[diff] [blame]1518}
1519
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1520bool RefLayerSupport::IsSliceSupported(const TensorInfo& input,
1521 const TensorInfo& output,
1522 const SliceDescriptor& descriptor,
1523 Optional<std::string&> reasonIfUnsupported) const
1524{
1525 ignore_unused(descriptor);
1526 bool supported = true;
1527
1528 std::array<DataType, 3> supportedTypes =
1529 {
1530 DataType::Float32,
1531 DataType::QuantisedAsymm8,
1532 DataType::QuantisedSymm16
1533 };
1534
1535 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1536 "Reference Slice: input type not supported");
1537
1538 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1539 "Reference Slice: output type not supported");
1540
1541 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1542 "Reference Slice: input and output types are mismatched");
1543
1544 return supported;
1545}
1546
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1547bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
1548 const TensorInfo& output,
1549 const SoftmaxDescriptor& descriptor,
1550 Optional<std::string&> reasonIfUnsupported) const
1551{
1552 ignore_unused(output);
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1553 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1554 std::array<DataType,4> supportedTypes =
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1555 {
1556 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1557 DataType::Float16,
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1558 DataType::QuantisedAsymm8,
1559 DataType::QuantisedSymm16
1560 };
1561
1562 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1563 "Reference Softmax: output type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1564
1565 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1566 "Reference Softmax: input type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1567
1568 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1569 "Reference Softmax: input type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1570
1571 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1572}
1573
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]1574bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
1575 const TensorInfo& output,
1576 const SpaceToBatchNdDescriptor& descriptor,
1577 Optional<std::string&> reasonIfUnsupported) const
1578{
1579 ignore_unused(output);
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1580 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1581 std::array<DataType,4> supportedTypes =
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1582 {
1583 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1584 DataType::Float16,
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1585 DataType::QuantisedAsymm8,
1586 DataType::QuantisedSymm16
1587 };
1588
1589 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1590 "Reference SpaceToBatchNd: input type not supported");
1591
1592 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1593 "Reference SpaceToBatchNd: output type not supported");
1594
1595 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1596 "Reference SpaceToBatchNd: input and output types are mismatched");
1597
1598 return supported;
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]1599}
1600
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]1601bool RefLayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
Keith Davis51910332019-06-26 15:28:43 +0100[diff] [blame]1602 const TensorInfo& output,
1603 const SpaceToDepthDescriptor& descriptor,
1604 Optional<std::string&> reasonIfUnsupported) const
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]1605{
1606
1607 ignore_unused(descriptor);
1608 bool supported = true;
1609
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1610 std::array<DataType,4> supportedTypes =
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]1611 {
1612 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1613 DataType::Float16,
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]1614 DataType::QuantisedAsymm8,
James Conroyd2aa85e2019-07-01 17:12:40 +0100[diff] [blame]1615 DataType::QuantisedSymm16
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]1616 };
1617
1618 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1619 "Reference SpaceToDepth: input type not supported");
1620
1621 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1622 "Reference SpaceToDepth: output type not supported");
1623
1624 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1625 "Reference SpaceToDepth: input and output types are mismatched");
1626
1627 return supported;
1628}
1629
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1630bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
1631 const ViewsDescriptor& descriptor,
1632 Optional<std::string&> reasonIfUnsupported) const
1633{
1634 ignore_unused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1635 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1636 std::array<DataType,4> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1637 {
1638 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1639 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1640 DataType::QuantisedAsymm8,
1641 DataType::QuantisedSymm16
1642 };
1643
1644 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1645 "Reference splitter: input type not supported");
1646
1647 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1648}
1649
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]1650bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
1651 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
1652 const ViewsDescriptor& descriptor,
1653 Optional<std::string&> reasonIfUnsupported) const
1654{
1655 ignore_unused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1656 bool supported = true;
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1657 std::array<DataType,4> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1658 {
1659 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1660 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1661 DataType::QuantisedAsymm8,
1662 DataType::QuantisedSymm16
1663 };
1664
1665 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1666 "Reference splitter: output type not supported");
1667 for (const TensorInfo output : outputs)
1668 {
1669 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1670 "Reference splitter: input type not supported");
1671
1672 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1673 "Reference splitter: input and output types mismatched.");
1674 }
1675
1676 return supported;
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]1677}
1678
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]1679bool RefLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
1680 const TensorInfo& output,
1681 const StackDescriptor& descriptor,
1682 Optional<std::string&> reasonIfUnsupported) const
1683{
1684 ignore_unused(descriptor);
1685
1686 bool supported = true;
Matthew Jacksone69c3992019-09-09 14:31:21 +0100[diff] [blame]1687 std::array<DataType,4> supportedTypes =
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]1688 {
1689 DataType::Float32,
Matthew Jacksone69c3992019-09-09 14:31:21 +0100[diff] [blame]1690 DataType::Float16,
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]1691 DataType::QuantisedAsymm8,
1692 DataType::QuantisedSymm16
1693 };
1694
1695 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1696 "Reference stack: output type not supported");
1697 for (const TensorInfo* input : inputs)
1698 {
1699 BOOST_ASSERT(input != nullptr);
1700 supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
1701 "Reference stack: input type not supported");
1702
1703 supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
1704 "Reference stack: input and output types mismatched.");
1705 }
1706
1707 return supported;
1708}
1709
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1710bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
1711 const TensorInfo& output,
1712 const StridedSliceDescriptor& descriptor,
1713 Optional<std::string&> reasonIfUnsupported) const
1714{
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1715 ignore_unused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1716 bool supported = true;
1717
1718 std::array<DataType,3> supportedTypes =
1719 {
1720 DataType::Float32,
1721 DataType::QuantisedAsymm8,
1722 DataType::QuantisedSymm16
1723 };
1724
1725 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1726 "Reference StridedSlice: input type not supported");
1727
1728 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1729 "Reference StridedSlice: output type not supported");
1730
1731 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1732 "Reference StridedSlice: input and output types are mismatched");
1733
1734 return supported;
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]1735}
1736
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1737bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
1738 const TensorInfo& input1,
1739 const TensorInfo& output,
1740 Optional<std::string&> reasonIfUnsupported) const
1741{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1742 bool supported = true;
1743
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1744 std::array<DataType,4> supportedTypes = {
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1745 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1746 DataType::Float16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1747 DataType::QuantisedAsymm8,
1748 DataType::QuantisedSymm16
1749 };
1750
1751 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1752 "Reference subtraction: input 0 is not a supported type.");
1753
1754 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1755 "Reference subtraction: input 1 is not a supported type.");
1756
1757 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1758 "Reference subtraction: output is not a supported type.");
1759
1760 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1761 "Reference subtraction: input 0 and Input 1 types are mismatched");
1762
1763 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1764 "Reference subtraction: input and output types are mismatched");
1765
1766 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1767 "Reference subtraction: shapes are not suitable for implicit broadcast.");
1768
1769 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1770}
1771
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]1772bool RefLayerSupport::IsPreluSupported(const TensorInfo& input,
1773 const TensorInfo& alpha,
1774 const TensorInfo& output,
1775 Optional<std::string&> reasonIfUnsupported) const
1776{
1777 bool supported = true;
1778
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1779 std::array<DataType, 4> supportedTypes
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]1780 {
1781 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1782 DataType::Float16,
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]1783 DataType::QuantisedAsymm8,
1784 DataType::QuantisedSymm16
1785 };
1786
1787 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1788 "PReLU: input is not a supported type.");
1789
1790 supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
1791 "PReLU: alpha is not a supported type.");
1792
1793 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1794 "PReLU: output is not a supported type.");
1795
1796 supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
1797 "PReLU: input, alpha and output types are mismatched");
1798
1799 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
1800 "PReLU: shapes are not suitable for implicit broadcast");
1801
1802 return supported;
1803}
1804
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1805bool RefLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
1806 const TensorInfo& output,
1807 const TransposeConvolution2dDescriptor& descriptor,
1808 const TensorInfo& weights,
1809 const Optional<TensorInfo>& biases,
1810 Optional<std::string&> reasonIfUnsupported) const
1811{
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1812 bool supported = true;
1813
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1814 std::array<DataType,4> supportedTypes =
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1815 {
1816 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1817 DataType::Float16,
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1818 DataType::QuantisedAsymm8,
1819 DataType::QuantisedSymm16
1820 };
1821
1822 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1823 "Reference TransposeConvolution2d: input is not a supported type.");
1824
1825 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1826 "Reference TransposeConvolution2d: output is not a supported type.");
1827
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1828 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1829 "Reference TransposeConvolution2d: input and output types mismatched.");
1830
Aron Virginas-Tar94d3b932019-11-11 12:54:47 +0000[diff] [blame]1831
1832 const DataType inputType = input.GetDataType();
1833 if (inputType == DataType::QuantisedAsymm8)
1834 {
1835 std::array<DataType, 2> supportedWeightTypes =
1836 {
1837 DataType::QuantisedAsymm8,
1838 DataType::QuantizedSymm8PerAxis
1839 };
1840
1841 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
1842 "Reference TransposeConvolution2d: weights type not supported for "
1843 "quantized input.");
1844 }
1845 else
1846 {
1847 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1848 "Reference TransposeConvolution2d: weights is not a supported type.");
1849
1850 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1851 "Reference TransposeConvolution2d: input and weights types mismatched.");
1852 }
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1853
1854 if (biases.has_value())
1855 {
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1856 std::array<DataType,3> biasesSupportedTypes =
Aron Virginas-Tar651aafe2019-08-05 11:52:05 +0100[diff] [blame]1857 {
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1858 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1859 DataType::Float16,
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]1860 DataType::Signed32
1861 };
1862 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
1863 "Reference TransposeConvolution2d: biases is not a supported type.");
1864 }
1865
1866 return supported;
1867}
1868
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1869} // namespace armnn