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