Gitiles
Code Review Sign In
review.mlplatform.org / ml / armnn / 529195f3ae752192d5f205345235bf537f472cbc / . / src / backends / reference / RefLayerSupport.cpp
blob: 4d4f01467163907fe187f181678996e68f7504ca [file] [log] [blame]
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]1//
Teresa Charlin52664732020-06-29 16:27:03 +0100[diff] [blame]2// Copyright © 2017 Arm Ltd and Contributors. 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 Beck3cc9a622018-10-12 10:38:31 +0100[diff] [blame]7
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]8#include <armnn/TypesUtils.hpp>
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>
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]11#include <armnn/utility/IgnoreUnused.hpp>
Matthew Sloyan171214c2020-09-09 09:07:37 +0100[diff] [blame]12#include <armnn/utility/NumericCast.hpp>
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]13
Matteo Martincighe011d202019-11-28 11:35:47 +0000[diff] [blame]14#include <LayerSupportCommon.hpp>
Derek Lambertif674aa02019-08-01 15:56:25 +0100[diff] [blame]15#include <backendsCommon/LayerSupportRules.hpp>
Matteo Martincighe011d202019-11-28 11:35:47 +0000[diff] [blame]16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]17#include <vector>
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]18#include <array>
19
telsoa014fcda012018-03-09 14:13:49 +0000[diff] [blame]20namespace armnn
21{
22
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]23namespace
24{
25
26template<typename Float32Func, typename Uint8Func, typename ... Params>
27bool IsSupportedForDataTypeRef(Optional<std::string&> reasonIfUnsupported,
28 DataType dataType,
29 Float32Func floatFuncPtr,
30 Uint8Func uint8FuncPtr,
31 Params&&... params)
32{
33 return IsSupportedForDataTypeGeneric(reasonIfUnsupported,
34 dataType,
35 &FalseFunc<Params...>,
36 floatFuncPtr,
37 uint8FuncPtr,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]38 &FalseFunc<Params...>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]39 &FalseFunc<Params...>,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]40 std::forward<Params>(params)...);
41}
42
43} // anonymous namespace
44
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]45namespace
46{
47
48std::string CreateIncorrectDimensionsErrorMsg(unsigned int expected,
49 unsigned int actual,
50 std::string& layerStr,
51 std::string& tensorName)
52{
53 std::string errorMsg = "Reference " + layerStr + ": Expected " + std::to_string(expected) + " dimensions but got" +
54 " " + std::to_string(actual) + " dimensions instead, for the '" + tensorName + "' tensor.";
55
56 return errorMsg;
57}
58
59} // anonymous namespace
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]60
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]61bool RefLayerSupport::IsActivationSupported(const TensorInfo& input,
62 const TensorInfo& output,
63 const ActivationDescriptor& descriptor,
64 Optional<std::string&> reasonIfUnsupported) const
65{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]66 bool supported = true;
67
68 // Define supported types.
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]69 std::array<DataType,6> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]70 DataType::BFloat16,
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]71 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]72 DataType::Float16,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]73 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]74 DataType::QAsymmU8,
75 DataType::QSymmS16
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]76 };
77
78 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
79 "Reference activation: input type not supported.");
80
81 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
82 "Reference activation: output type not supported.");
83
84 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
85 "Reference activation: input and output types mismatched.");
86
87 supported &= CheckSupportRule(ShapesAreSameRank(input, output), reasonIfUnsupported,
88 "Reference activation: input and output shapes are of different rank.");
89
90
91 struct ActivationFunctionSupported : public Rule
92 {
93 ActivationFunctionSupported(const ActivationDescriptor& desc)
94 {
95 switch(desc.m_Function)
96 {
97 case ActivationFunction::Abs:
98 case ActivationFunction::BoundedReLu:
David Monahan3b3c3812020-02-25 09:03:29 +0000[diff] [blame]99 case ActivationFunction::Elu:
Colm Donelan03fbeaf2020-02-26 15:39:23 +0000[diff] [blame]100 case ActivationFunction::HardSwish:
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]101 case ActivationFunction::LeakyReLu:
102 case ActivationFunction::Linear:
103 case ActivationFunction::ReLu:
104 case ActivationFunction::Sigmoid:
105 case ActivationFunction::SoftReLu:
106 case ActivationFunction::Sqrt:
107 case ActivationFunction::Square:
108 case ActivationFunction::TanH:
109 {
110 m_Res = true;
111 break;
112 }
113 default:
114 {
115 m_Res = false;
116 break;
117 }
118 }
119 }
120 };
121
122 // Function is supported
123 supported &= CheckSupportRule(ActivationFunctionSupported(descriptor), reasonIfUnsupported,
124 "Reference activation: function not supported.");
125
126 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]127}
128
129bool RefLayerSupport::IsAdditionSupported(const TensorInfo& input0,
130 const TensorInfo& input1,
131 const TensorInfo& output,
132 Optional<std::string&> reasonIfUnsupported) const
133{
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]134 bool supported = true;
135
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]136 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]137 DataType::BFloat16,
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]138 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]139 DataType::Float16,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]140 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]141 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]142 DataType::QSymmS16,
143 DataType::Signed32
Derek Lamberti50db4e82019-03-13 14:16:15 +0000[diff] [blame]144 };
145
146 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
147 "Reference addition: input 0 is not a supported type.");
148
149 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
150 "Reference addition: input 1 is not a supported type.");
151
152 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
153 "Reference addition: output is not a supported type.");
154
155 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
156 "Reference addition: input 0 and Input 1 types are mismatched");
157
158 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
159 "Reference addition: input and output types are mismatched");
160
161 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
162 "Reference addition: shapes are not suitable for implicit broadcast.");
163
164 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]165}
166
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]167bool RefLayerSupport::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output,
168 const armnn::ArgMinMaxDescriptor &descriptor,
169 armnn::Optional<std::string &> reasonIfUnsupported) const
170{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]171 IgnoreUnused(descriptor);
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]172
Mike Kelly1f140f72021-04-06 12:25:55 +0100[diff] [blame]173 std::array<DataType, 8> supportedInputTypes =
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]174 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]175 DataType::BFloat16,
Teresa Charline300b362020-05-25 10:01:03 +0100[diff] [blame]176 DataType::Float16,
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]177 DataType::Float32,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]178 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]179 DataType::QAsymmU8,
180 DataType::QSymmS16,
Mike Kelly1f140f72021-04-06 12:25:55 +0100[diff] [blame]181 DataType::Signed32,
182 DataType::Signed64
183 };
184
185 std::array<DataType,2> supportedOutputTypes = {
186 DataType::Signed32,
187 DataType::Signed64
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]188 };
189
190 bool supported = true;
191
Mike Kelly1f140f72021-04-06 12:25:55 +0100[diff] [blame]192 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]193 "Reference ArgMinMax: input is not a supported type.");
Mike Kelly1f140f72021-04-06 12:25:55 +0100[diff] [blame]194 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
Nikhil Raj68c2c902019-09-19 11:21:11 +0100[diff] [blame]195 "Reference ArgMinMax: output type not supported");
196
197 return supported;
198}
199
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]200bool RefLayerSupport::IsBatchNormalizationSupported(const TensorInfo& input,
201 const TensorInfo& output,
202 const TensorInfo& mean,
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]203 const TensorInfo& variance,
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]204 const TensorInfo& beta,
205 const TensorInfo& gamma,
206 const BatchNormalizationDescriptor& descriptor,
207 Optional<std::string&> reasonIfUnsupported) const
208{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]209 IgnoreUnused(descriptor);
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]210
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]211 std::array<DataType, 6> supportedTypes =
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]212 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]213 DataType::BFloat16,
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]214 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]215 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]216 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]217 DataType::QAsymmU8,
218 DataType::QSymmS16
Matteo Martincigh3122bd52019-06-03 16:54:25 +0100[diff] [blame]219 };
220
221 bool supported = true;
222
223 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
224 "Reference batch normalization: input is not a supported type.");
225
226 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
227 "Reference batch normalization: output is not a supported type.");
228
229 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
230 "Reference batch normalization: input and output types are mismatched");
231
232 supported &= CheckSupportRule(TypeAnyOf(mean, supportedTypes), reasonIfUnsupported,
233 "Reference batch normalization: mean is not a supported type.");
234
235 supported &= CheckSupportRule(TypeAnyOf(variance, supportedTypes), reasonIfUnsupported,
236 "Reference batch normalization: variance is not a supported type.");
237
238 supported &= CheckSupportRule(TypeAnyOf(beta, supportedTypes), reasonIfUnsupported,
239 "Reference batch normalization: beta is not a supported type.");
240
241 supported &= CheckSupportRule(TypeAnyOf(gamma, supportedTypes), reasonIfUnsupported,
242 "Reference batch normalization: gamma is not a supported type.");
243
244 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]245}
246
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]247bool RefLayerSupport::IsBatchToSpaceNdSupported(const TensorInfo& input,
248 const TensorInfo& output,
249 const BatchToSpaceNdDescriptor& descriptor,
250 Optional<std::string&> reasonIfUnsupported) const
251{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]252 IgnoreUnused(descriptor);
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]253
254 bool supported = true;
255
256 std::string batchToSpaceNdLayerStr = "batchToSpaceNd";
257 std::string inputTensorStr = "input";
258 std::string outputTensorStr = "output";
259
260 // Define supported types.
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]261 std::array<DataType,6> supportedTypes =
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]262 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]263 DataType::BFloat16,
264 DataType::Float32,
265 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]266 DataType::QAsymmS8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]267 DataType::QAsymmU8,
268 DataType::QSymmS16
Francis Murtaghd0dfe172019-06-25 10:57:10 +0100[diff] [blame]269 };
270
271 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
272 "Reference BatchToSpaceNd: input type not supported.");
273
274 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
275 "Reference BatchToSpaceNd: output type not supported.");
276
277 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
278 "Reference BatchToSpaceNd: input and output types mismatched.");
279
280 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 4),
281 reasonIfUnsupported,
282 CreateIncorrectDimensionsErrorMsg(4,
283 output.GetNumDimensions(),
284 batchToSpaceNdLayerStr,
285 outputTensorStr).data());
286
287 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(input, 4),
288 reasonIfUnsupported,
289 CreateIncorrectDimensionsErrorMsg(4,
290 input.GetNumDimensions(),
291 batchToSpaceNdLayerStr,
292 inputTensorStr).data());
293
294 return supported;
Éanna Ó Catháin4e1e1362018-11-12 11:36:34 +0000[diff] [blame]295}
296
mathad01b392e982021-04-07 12:07:30 +0100[diff] [blame]297bool RefLayerSupport::IsCastSupported(const TensorInfo& input,
298 const TensorInfo& output,
299 Optional<std::string&> reasonIfUnsupported) const
300{
301 std::array<DataType, 9> supportedInputTypes =
302 {
303 DataType::BFloat16,
304 DataType::Float32,
305 DataType::Float16,
306 DataType::QSymmS8,
307 DataType::QAsymmS8,
308 DataType::QAsymmU8,
309 DataType::QSymmS16,
310 DataType::Signed32
311 };
312
313 bool supported = true;
314 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
315 "Reference cast: input is not a supported type");
316
317
318 supported &= CheckSupportRule(TypeAnyOf(output, supportedInputTypes), reasonIfUnsupported,
319 "Reference cast: output is not a supported type");
320
321 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
322 "Reference cast: input and output shapes have different number of total elements");
323
324 return supported;
325}
326
Simon Obute51f67772021-09-03 15:50:13 +0100[diff] [blame]327bool RefLayerSupport::IsChannelShuffleSupported(const TensorInfo& input,
328 const TensorInfo& output,
329 const ChannelShuffleDescriptor& descriptor,
330 Optional<std::string&> reasonIfUnsupported) const
331{
332 IgnoreUnused(descriptor);
333 bool supported = true;
334
335 // Define supported output and inputs types.
336 std::array<DataType, 7> supportedTypes =
337 {
338 DataType::BFloat16,
339 DataType::Float32,
340 DataType::Float16,
341 DataType::QAsymmS8,
342 DataType::QAsymmU8,
343 DataType::QSymmS8,
344 DataType::QSymmS16
345 };
346
347 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
348 "Reference ChannelShuffle: input is not a supported type.");
349
350 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
351 "Reference ChannelShuffle: output is not a supported type.");
352
353 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
354 "Reference ChannelShuffle: input and output types are mismatched.");
355
356 return supported;
357}
358
359
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]360bool RefLayerSupport::IsComparisonSupported(const TensorInfo& input0,
361 const TensorInfo& input1,
362 const TensorInfo& output,
363 const ComparisonDescriptor& descriptor,
364 Optional<std::string&> reasonIfUnsupported) const
365{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]366 IgnoreUnused(descriptor);
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]367 std::array<DataType, 8> supportedInputTypes =
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]368 {
Sadik Armaganb60dd242020-03-19 13:53:16 +0000[diff] [blame]369 DataType::Boolean,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]370 DataType::BFloat16,
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]371 DataType::Float32,
372 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]373 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]374 DataType::QAsymmU8,
Sadik Armaganb60dd242020-03-19 13:53:16 +0000[diff] [blame]375 DataType::QSymmS16,
376 DataType::Signed32
Aron Virginas-Tar77bfb5e2019-10-16 17:45:38 +0100[diff] [blame]377 };
378
379 bool supported = true;
380 supported &= CheckSupportRule(TypeAnyOf(input0, supportedInputTypes), reasonIfUnsupported,
381 "Reference comparison: input 0 is not a supported type");
382
383 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
384 "Reference comparison: input 0 and Input 1 types are mismatched");
385
386 supported &= CheckSupportRule(TypeIs(output, DataType::Boolean), reasonIfUnsupported,
387 "Reference comparison: output is not of type Boolean");
388
389 return supported;
390}
391
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]392bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
393 const TensorInfo& output,
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]394 const ConcatDescriptor& descriptor,
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]395 Optional<std::string&> reasonIfUnsupported) const
396{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]397 IgnoreUnused(descriptor);
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]398
399 bool supported = true;
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]400 std::array<DataType,6> supportedTypes =
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]401 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]402 DataType::BFloat16,
403 DataType::Float32,
404 DataType::Float16,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]405 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]406 DataType::QAsymmU8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]407 DataType::QSymmS16
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]408 };
409
410 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
411 "Reference concatenation: output type not supported");
412 for (const TensorInfo* input : inputs)
413 {
Narumol Prangnawaratac2770a2020-04-01 16:51:23 +0100[diff] [blame]414 ARMNN_ASSERT(input != nullptr);
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]415 supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
416 "Reference concatenation: input type not supported");
417
418 supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
419 "Reference concatenation: input and output types mismatched.");
420 }
421
422 return supported;
Jim Flynn906f9462019-05-10 13:55:21 +0100[diff] [blame]423}
424
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]425bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
426 Optional<std::string&> reasonIfUnsupported) const
427{
Teresa Charlin6fa8ce62020-05-25 16:16:44 +0100[diff] [blame]428 std::array<DataType,8> supportedTypes =
Jim Flynne242f2d2019-05-22 14:24:13 +0100[diff] [blame]429 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]430 DataType::BFloat16,
Teresa Charlin6fa8ce62020-05-25 16:16:44 +0100[diff] [blame]431 DataType::Float16,
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]432 DataType::Float32,
Keith Davis67e6c542020-02-19 10:08:33 +0000[diff] [blame]433 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]434 DataType::QAsymmU8,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]435 DataType::QSymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]436 DataType::QSymmS16,
437 DataType::Signed32
Nina Drozd58ef2c62019-05-16 12:09:18 +0100[diff] [blame]438 };
439
440 return CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
441 "Reference constant: output is not a supported type.");
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]442}
443
Narumol Prangnawarat7ddbbae2020-03-13 10:26:05 +0000[diff] [blame]444bool RefLayerSupport::IsConvertBf16ToFp32Supported(const TensorInfo& input,
445 const TensorInfo& output,
446 Optional<std::string&> reasonIfUnsupported) const
447{
448 bool supported = true;
449
450 supported &= CheckSupportRule(TypeIs(input, DataType::BFloat16), reasonIfUnsupported,
451 "Reference for ConvertBf16ToFp32 layer: input type not supported");
452
453 supported &= CheckSupportRule(TypeIs(output, DataType::Float32), reasonIfUnsupported,
454 "Reference for ConvertBf16ToFp32 layer: output type not supported");
455
456 return supported;
457}
458
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]459bool RefLayerSupport::IsConvertFp16ToFp32Supported(const TensorInfo& input,
460 const TensorInfo& output,
461 Optional<std::string&> reasonIfUnsupported) const
462{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]463 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
464 input.GetDataType(),
465 &TrueFunc<>,
466 &FalseInputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]467 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]468 &FalseFuncI32<>,
469 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]470 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
471 output.GetDataType(),
472 &FalseOutputFuncF16<>,
473 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]474 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]475 &FalseFuncI32<>,
476 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]477}
478
Narumol Prangnawaratea54a012020-03-16 16:36:10 +0000[diff] [blame]479bool RefLayerSupport::IsConvertFp32ToBf16Supported(const TensorInfo& input,
480 const TensorInfo& output,
481 Optional<std::string&> reasonIfUnsupported) const
482{
483 bool supported = true;
484
485 supported &= CheckSupportRule(TypeIs(input, DataType::Float32), reasonIfUnsupported,
486 "Reference for ConvertFp32ToBf16 layer: input type not supported");
487
488 supported &= CheckSupportRule(TypeIs(output, DataType::BFloat16), reasonIfUnsupported,
489 "Reference for ConvertFp32ToBf16 layer: output type not supported");
490
491 return supported;
492}
493
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]494bool RefLayerSupport::IsConvertFp32ToFp16Supported(const TensorInfo& input,
495 const TensorInfo& output,
496 Optional<std::string&> reasonIfUnsupported) const
497{
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]498 return (IsSupportedForDataTypeGeneric(reasonIfUnsupported,
499 input.GetDataType(),
500 &FalseInputFuncF16<>,
501 &TrueFunc<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]502 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]503 &FalseFuncI32<>,
504 &FalseFuncU8<>) &&
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]505 IsSupportedForDataTypeGeneric(reasonIfUnsupported,
506 output.GetDataType(),
507 &TrueFunc<>,
508 &FalseOutputFuncF32<>,
narpra01db2b1602019-01-23 15:23:11 +0000[diff] [blame]509 &FalseFuncU8<>,
kevmay012b4d88e2019-01-24 14:05:09 +0000[diff] [blame]510 &FalseFuncI32<>,
511 &FalseFuncU8<>));
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]512}
513
514bool RefLayerSupport::IsConvolution2dSupported(const TensorInfo& input,
515 const TensorInfo& output,
516 const Convolution2dDescriptor& descriptor,
517 const TensorInfo& weights,
518 const Optional<TensorInfo>& biases,
519 Optional<std::string&> reasonIfUnsupported) const
520{
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]521 bool supported = true;
522
523 // Define supported types.
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]524 std::array<DataType,7> supportedTypes =
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]525 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]526 DataType::BFloat16,
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]527 DataType::Float32,
528 DataType::Float16,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]529 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]530 DataType::QAsymmU8,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]531 DataType::QSymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]532 DataType::QSymmS16
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]533 };
534
535 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]536 "Reference Convolution2d: input is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]537
538 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]539 "Reference Convolution2d: output is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]540
Narumol Prangnawarat57ef0082020-03-26 09:20:43 +0000[diff] [blame]541 // For Convolution2d, we allow to have BFloat16 input with Float32 output for optimization.
542 if (input.GetDataType() == DataType::BFloat16)
543 {
544 if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
545 {
546 reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
547 supported = false;
548 }
549 }
550 else
551 {
552 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]553 "Reference Convolution2d: input and output types mismatched.");
Narumol Prangnawarat57ef0082020-03-26 09:20:43 +0000[diff] [blame]554 }
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]555
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]556 const DataType inputType = input.GetDataType();
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]557 if (IsQuantized8BitType(inputType))
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]558 {
Jan Eilers1b2654f2021-09-24 15:45:46 +0100[diff] [blame]559 std::array<DataType, 3> supportedWeightTypes =
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]560 {
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]561 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]562 DataType::QAsymmU8,
Jan Eilers1b2654f2021-09-24 15:45:46 +0100[diff] [blame]563 DataType::QSymmS8
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]564 };
565
566 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]567 "Reference Convolution2d: weights type not supported for quantized input.");
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]568 }
569 else
570 {
571 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]572 "Reference Convolution2d: weights is not a supported type.");
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]573
574 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]575 "Reference Convolution2d: input and weights types mismatched.");
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]576 }
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]577
578 if (biases.has_value())
579 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]580 std::array<DataType,4> biasesSupportedTypes =
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]581 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]582 DataType::BFloat16,
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]583 DataType::Float32,
584 DataType::Float16,
585 DataType::Signed32
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]586 };
Aron Virginas-Tar5edc8812019-11-05 18:00:21 +0000[diff] [blame]587
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]588 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]589 "Reference Convolution2d: biases is not a supported type.");
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]590 }
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]591 IgnoreUnused(descriptor);
Mike Kelly2f80f6e2019-05-16 12:41:34 +0100[diff] [blame]592
593 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]594}
595
Matthew Sloyanb63a3112021-09-08 13:05:51 +0100[diff] [blame]596bool RefLayerSupport::IsConvolution3dSupported(const TensorInfo& input,
597 const TensorInfo& output,
598 const Convolution3dDescriptor& descriptor,
599 const TensorInfo& weights,
600 const Optional<TensorInfo>& biases,
601 Optional<std::string&> reasonIfUnsupported) const
602{
603 bool supported = true;
604
605 // Define supported types.
606 std::array<DataType,7> supportedTypes =
607 {
608 DataType::BFloat16,
609 DataType::Float32,
610 DataType::Float16,
611 DataType::QAsymmS8,
612 DataType::QAsymmU8,
613 DataType::QSymmS8,
614 DataType::QSymmS16
615 };
616
617 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
618 "Reference Convolution3d: input is not a supported type.");
619
620 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
621 "Reference Convolution3d: output is not a supported type.");
622
623 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
624 "Reference Convolution3d: input and output types mismatched.");
625
626 const DataType inputType = input.GetDataType();
627 if (IsQuantized8BitType(inputType))
628 {
629 std::array<DataType, 3> supportedWeightTypes =
630 {
631 DataType::QAsymmS8,
632 DataType::QAsymmU8,
633 DataType::QSymmS8
634 };
635
636 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
637 "Reference Convolution3d: weights type not supported for quantized input.");
638 }
639 else
640 {
641 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
642 "Reference Convolution3d: weights is not a supported type.");
643
644 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
645 "Reference Convolution3d: input and weights types mismatched.");
646 }
647
648 if (biases.has_value())
649 {
650 std::array<DataType,4> biasesSupportedTypes =
651 {
652 DataType::BFloat16,
653 DataType::Float32,
654 DataType::Float16,
655 DataType::Signed32
656 };
657
658 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
659 "Reference Convolution3d: biases is not a supported type.");
660 }
661 IgnoreUnused(descriptor);
662
663 return supported;
664}
665
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]666bool RefLayerSupport::IsDebugSupported(const TensorInfo& input,
667 const TensorInfo& output,
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]668 Optional<std::string&> reasonIfUnsupported) const
669{
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]670 bool supported = true;
671
Narumol Prangnawarat403a1852020-03-12 14:24:13 +0000[diff] [blame]672 std::array<DataType, 8> supportedTypes =
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]673 {
Narumol Prangnawarat403a1852020-03-12 14:24:13 +0000[diff] [blame]674 DataType::BFloat16,
Aron Virginas-Tardb1a2832019-11-12 16:15:11 +0000[diff] [blame]675 DataType::Float16,
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]676 DataType::Float32,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]677 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]678 DataType::QAsymmU8,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]679 DataType::QSymmS8,
Narumol Prangnawaratd2d917d2020-01-09 10:16:39 +0000[diff] [blame]680 DataType::QSymmS16,
681 DataType::Signed32
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]682 };
683
684 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]685 "Reference for Debug layer: input type not supported");
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]686
687 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]688 "Reference for Debug layer: output type not supported");
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]689
690 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]691 "Reference for Debug layer: input and output types are mismatched");
Narumol Prangnawarat47cfee92019-07-04 10:29:00 +0100[diff] [blame]692
693 return supported;
Nattapat Chaimanowongcfdcadf2018-12-06 11:54:33 +0000[diff] [blame]694}
695
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]696bool RefLayerSupport::IsDepthToSpaceSupported(const TensorInfo& input,
697 const TensorInfo& output,
698 const DepthToSpaceDescriptor& descriptor,
699 Optional<std::string&> reasonIfUnsupported) const
700{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]701 IgnoreUnused(descriptor);
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]702 bool supported = true;
703
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]704 std::array<DataType,6> supportedTypes =
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]705 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]706 DataType::BFloat16,
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]707 DataType::Float32,
708 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]709 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]710 DataType::QAsymmU8,
711 DataType::QSymmS16
Aron Virginas-Tar73f66422019-09-23 19:11:59 +0100[diff] [blame]712 };
713
714 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
715 "Reference DepthToSpace: input type not supported");
716
717 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
718 "Reference DepthToSpace: output type not supported");
719
720 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
721 "Reference DepthToSpace: input and output types are mismatched");
722
723 return supported;
724}
725
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]726bool RefLayerSupport::IsDepthwiseConvolutionSupported(const TensorInfo& input,
727 const TensorInfo& output,
728 const DepthwiseConvolution2dDescriptor& descriptor,
729 const TensorInfo& weights,
730 const Optional<TensorInfo>& biases,
731 Optional<std::string&> reasonIfUnsupported) const
732{
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]733 IgnoreUnused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]734 bool supported = true;
735
736 // Define supported types.
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]737 std::array<DataType,7> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]738 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]739 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]740 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]741 DataType::Float16,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]742 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]743 DataType::QAsymmU8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]744 DataType::QSymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]745 DataType::QSymmS16
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]746 };
747
748 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
749 "Reference DepthwiseConvolution2d: input is not a supported type.");
750
751 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
752 "Reference DepthwiseConvolution2d: output is not a supported type.");
753
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]754 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
755 "Reference DepthwiseConvolution2d: input and output types mismatched.");
756
Teresa Charlind8df0262019-11-11 12:28:15 +0000[diff] [blame]757 const DataType inputType = input.GetDataType();
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]758 if (IsQuantized8BitType(inputType))
Teresa Charlind8df0262019-11-11 12:28:15 +0000[diff] [blame]759 {
Jan Eilers1b2654f2021-09-24 15:45:46 +0100[diff] [blame]760 std::array<DataType, 3> supportedWeightTypes =
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]761 {
762 DataType::QAsymmS8,
763 DataType::QAsymmU8,
764 DataType::QSymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]765 };
Teresa Charlind8df0262019-11-11 12:28:15 +0000[diff] [blame]766
767 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]768 "Reference DepthwiseConvolution2d: weights type not supported for "
769 "quantized input.");
Teresa Charlind8df0262019-11-11 12:28:15 +0000[diff] [blame]770 }
771 else
772 {
773 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
774 "Reference DepthwiseConvolution2d: weights is not a supported type.");
775
776 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
777 "Reference DepthwiseConvolution2d: input and weights types mismatched.");
778 }
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]779
780 if (biases.has_value())
781 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]782 std::array<DataType,4> biasesSupportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]783 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]784 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]785 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]786 DataType::Float16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]787 DataType::Signed32
788 };
789 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
790 "Reference DepthwiseConvolution2d: biases is not a supported type.");
791 }
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]792
793 return supported;
794
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]795}
796
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]797bool RefLayerSupport::IsDequantizeSupported(const TensorInfo& input,
798 const TensorInfo& output,
799 Optional<std::string&> reasonIfUnsupported) const
800{
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]801 bool supported = true;
802
Ryan OShea9add1202020-02-07 10:06:33 +0000[diff] [blame]803 std::array<DataType,4> supportedInputTypes = {
804 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]805 DataType::QAsymmU8,
Finn Williamsfd271062019-12-04 14:27:27 +0000[diff] [blame]806 DataType::QSymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]807 DataType::QSymmS16
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]808 };
809
810 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]811 "Reference for Dequantize layer: input type not supported.");
812
Derek Lambertid466a542020-01-22 15:37:29 +0000[diff] [blame]813 supported &= CheckSupportRule(TypeNotPerAxisQuantized(input), reasonIfUnsupported,
Teresa Charlin1b1950d2021-06-02 20:23:21 +0100[diff] [blame]814 "Reference for Dequantize layer: per-axis quantized input not supported.");
Derek Lambertid466a542020-01-22 15:37:29 +0000[diff] [blame]815
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]816 std::array<DataType,3> supportedOutputTypes = {
817 DataType::BFloat16,
Jan Eilersf7107932019-11-01 11:09:36 +0000[diff] [blame]818 DataType::Float32,
819 DataType::Float16
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]820 };
821
822 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]823 "Reference for Dequantize layer: output type not supported.");
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]824
825 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
Keith Davis5204aa82020-01-27 15:24:59 +0000[diff] [blame]826 "Reference for Dequantize layer: input/output shapes have different num total "
827 "elements.");
Nattapat Chaimanowongafa4e3a2019-04-02 11:41:45 +0100[diff] [blame]828
829 return supported;
Nattapat Chaimanowong8a54ac02019-03-29 15:25:04 +0000[diff] [blame]830}
831
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame]832bool RefLayerSupport::IsDetectionPostProcessSupported(const TensorInfo& boxEncodings,
833 const TensorInfo& scores,
834 const TensorInfo& anchors,
835 const TensorInfo& detectionBoxes,
836 const TensorInfo& detectionClasses,
837 const TensorInfo& detectionScores,
838 const TensorInfo& numDetections,
839 const DetectionPostProcessDescriptor& descriptor,
840 Optional<std::string&> reasonIfUnsupported) const
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame]841{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]842 IgnoreUnused(anchors, detectionBoxes, detectionClasses, detectionScores, numDetections, descriptor);
Derek Lamberti901ea112019-12-10 22:07:09 +0000[diff] [blame]843
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]844 bool supported = true;
845
Sadik Armaganaa41d5d2020-11-16 14:27:52 +0000[diff] [blame]846 std::array<DataType,6> supportedInputTypes =
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]847 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]848 DataType::BFloat16,
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]849 DataType::Float32,
Sadik Armaganaa41d5d2020-11-16 14:27:52 +0000[diff] [blame]850 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]851 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]852 DataType::QAsymmU8,
853 DataType::QSymmS16
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]854 };
855
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame]856 supported &= CheckSupportRule(TypeAnyOf(boxEncodings, supportedInputTypes), reasonIfUnsupported,
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]857 "Reference DetectionPostProcess: input 0 is not a supported type.");
858
Derek Lamberti6a5e5e82019-12-05 14:41:20 +0000[diff] [blame]859 supported &= CheckSupportRule(TypeAnyOf(scores, supportedInputTypes), reasonIfUnsupported,
Aron Virginas-Tara37e1bd2019-06-06 16:08:30 +0100[diff] [blame]860 "Reference DetectionPostProcess: input 1 is not a supported type.");
861
862 return supported;
Narumol Prangnawaratbc67cef2019-01-31 15:31:54 +0000[diff] [blame]863}
864
Pablo Tellof0bd6832019-04-26 17:58:13 +0100[diff] [blame]865bool RefLayerSupport::IsDilatedDepthwiseConvolutionSupported(const TensorInfo& input,
866 const TensorInfo& output,
867 const DepthwiseConvolution2dDescriptor& descriptor,
868 const TensorInfo& weights,
869 const Optional<TensorInfo>& biases,
870 Optional<std::string&> reasonIfUnsupported) const
871{
Aron Virginas-Taraece4ed2019-06-14 17:00:09 +0100[diff] [blame]872 return IsDepthwiseConvolutionSupported(input, output, descriptor, weights, biases, reasonIfUnsupported);
Pablo Tellof0bd6832019-04-26 17:58:13 +0100[diff] [blame]873}
874
Aron Virginas-Taraece4ed2019-06-14 17:00:09 +0100[diff] [blame]875bool RefLayerSupport::IsDivisionSupported(const TensorInfo& input0,
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]876 const TensorInfo& input1,
877 const TensorInfo& output,
878 Optional<std::string&> reasonIfUnsupported) const
879{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]880 bool supported = true;
881
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]882 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]883 DataType::BFloat16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]884 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]885 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]886 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]887 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]888 DataType::QSymmS16,
889 DataType::Signed32
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]890 };
891
892 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
893 "Reference division: input 0 is not a supported type.");
894
895 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
896 "Reference division: input 1 is not a supported type.");
897
898 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
899 "Reference division: output is not a supported type.");
900
901 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
902 "Reference division: input 0 and Input 1 types are mismatched");
903
904 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
905 "Reference division: input and output types are mismatched");
906
907 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
908 "Reference division: shapes are not suitable for implicit broadcast.");
909
910 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]911}
912
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]913bool RefLayerSupport::IsElementwiseUnarySupported(const TensorInfo& input,
914 const TensorInfo& output,
915 const ElementwiseUnaryDescriptor& descriptor,
916 Optional<std::string&> reasonIfUnsupported) const
917{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]918 IgnoreUnused(descriptor);
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]919
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]920 std::array<DataType, 7> supportedTypes =
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]921 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]922 DataType::BFloat16,
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]923 DataType::Float32,
924 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]925 DataType::QAsymmS8,
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]926 DataType::QAsymmU8,
Sadik Armaganac472102020-03-24 09:54:36 +0000[diff] [blame]927 DataType::QSymmS16,
928 DataType::Signed32
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]929 };
930
Narumol Prangnawarat0c95f4c2020-11-18 16:52:07 +0000[diff] [blame]931 std::array<DataType, 1> logicalSupportedTypes =
932 {
933 DataType::Boolean
934 };
935
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]936 bool supported = true;
937
Narumol Prangnawarat0c95f4c2020-11-18 16:52:07 +0000[diff] [blame]938 if (descriptor.m_Operation == UnaryOperation::LogicalNot)
939 {
940 supported &= CheckSupportRule(TypeAnyOf(input, logicalSupportedTypes), reasonIfUnsupported,
941 "Reference elementwise unary: input type not supported");
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]942
Narumol Prangnawarat0c95f4c2020-11-18 16:52:07 +0000[diff] [blame]943 supported &= CheckSupportRule(TypeAnyOf(output, logicalSupportedTypes), reasonIfUnsupported,
944 "Reference elementwise unary: output type not supported");
945 }
946 else
947 {
948 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
949 "Reference elementwise unary: input type not supported");
950
951 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
952 "Reference elementwise unary: output type not supported");
953 }
josh minor4a3c6102020-01-06 16:40:46 -0600[diff] [blame]954
955 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
956 "Reference elementwise unary: input and output types not matching");
957
958 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
959 "Reference elementwise unary: input and output shapes"
960 "have different number of total elements");
961
962 return supported;
963}
964
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]965bool RefLayerSupport::IsFakeQuantizationSupported(const TensorInfo& input,
966 const FakeQuantizationDescriptor& descriptor,
967 Optional<std::string&> reasonIfUnsupported) const
968{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]969 IgnoreUnused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]970 bool supported = true;
971
972 std::array<DataType,1> supportedTypes =
973 {
974 DataType::Float32
975 };
976
977 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
978 "Reference fake quantization: input type not supported.");
979
980 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]981}
982
Ryan OSheaf4bfa6a2020-06-10 11:33:37 +0100[diff] [blame]983bool RefLayerSupport::IsFillSupported(const TensorInfo& input,
984 const TensorInfo& output,
985 const FillDescriptor& descriptor,
986 Optional<std::string&> reasonIfUnsupported) const
987{
988 IgnoreUnused(descriptor);
989 IgnoreUnused(output);
990
991 bool supported = true;
992
Sadik Armagana792a052020-06-23 16:22:23 +0100[diff] [blame]993 std::array<DataType,3> supportedTypes =
Ryan OSheaf4bfa6a2020-06-10 11:33:37 +0100[diff] [blame]994 {
995 DataType::Float32,
Sadik Armagana792a052020-06-23 16:22:23 +0100[diff] [blame]996 DataType::Float16,
997 DataType::Signed32
Ryan OSheaf4bfa6a2020-06-10 11:33:37 +0100[diff] [blame]998 };
999
Teresa Charlin4b10fef2020-07-29 09:36:41 +0100[diff] [blame]1000 supported &= CheckSupportRule(TypeIs(input, DataType::Signed32), reasonIfUnsupported,
Ryan OSheaf4bfa6a2020-06-10 11:33:37 +0100[diff] [blame]1001 "Reference Fill: input type not supported.");
1002
Teresa Charlin44088502020-07-27 11:27:19 +0100[diff] [blame]1003 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1004 "Reference Fill: output type not supported.");
Ryan OSheaf4bfa6a2020-06-10 11:33:37 +0100[diff] [blame]1005 return supported;
1006}
1007
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1008bool RefLayerSupport::IsFloorSupported(const TensorInfo& input,
1009 const TensorInfo& output,
1010 Optional<std::string&> reasonIfUnsupported) const
1011{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1012 IgnoreUnused(output);
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]1013 bool supported = true;
1014
Francis Murtaghe8ac1332020-07-30 18:03:40 +0100[diff] [blame]1015 std::array<DataType,3> supportedTypes =
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]1016 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1017 DataType::BFloat16,
James Conroyb40d7102019-06-04 12:32:09 +0100[diff] [blame]1018 DataType::Float32,
Francis Murtaghe8ac1332020-07-30 18:03:40 +0100[diff] [blame]1019 DataType::Float16
James Conroy83735b12019-05-30 16:36:59 +0100[diff] [blame]1020 };
1021
1022 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1023 "Reference Floor: input type not supported.");
1024
1025 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1026 "Reference Floor: output type not supported.");
1027
1028 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1029}
1030
1031bool RefLayerSupport::IsFullyConnectedSupported(const TensorInfo& input,
1032 const TensorInfo& output,
1033 const TensorInfo& weights,
1034 const TensorInfo& biases,
1035 const FullyConnectedDescriptor& descriptor,
1036 Optional<std::string&> reasonIfUnsupported) const
1037{
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1038 bool supported = true;
1039
1040 // Define supported types.
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1041 std::array<DataType,6> supportedTypes =
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1042 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1043 DataType::BFloat16,
1044 DataType::Float32,
1045 DataType::Float16,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1046 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1047 DataType::QAsymmU8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1048 DataType::QSymmS16
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1049 };
1050
1051 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1052 "Reference Fully Connected: input type not supported.");
1053
1054 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1055 "Reference Fully Connected: output type not supported.");
1056
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1057 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1058 "Reference Fully Connected: weights type not supported.");
1059
Narumol Prangnawarat57ef0082020-03-26 09:20:43 +0000[diff] [blame]1060 // For FullyConnected, we allow to have BFloat16 input with Float32 output for optimization.
1061 if (input.GetDataType() == DataType::BFloat16)
1062 {
1063 if (output.GetDataType() != DataType::BFloat16 && output.GetDataType() != DataType::Float32)
1064 {
1065 reasonIfUnsupported.value() += "Output tensor type must be BFloat16 or Float32 for BFloat16 input.\n";
1066 supported = false;
1067 }
1068 }
1069 else
1070 {
1071 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1072 "Reference Fully Connected: input and output types mismatched.");
1073 }
1074
Jan Eilers1f45dc32020-06-15 11:43:03 +0100[diff] [blame]1075 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
1076 "Reference Fully Connected: weights is not a supported type.");
Francis Murtaghddb1d062020-03-10 13:51:45 +0000[diff] [blame]1077
Jan Eilers1f45dc32020-06-15 11:43:03 +0100[diff] [blame]1078 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
1079 "Reference Fully Connected: input and weights types mismatched.");
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1080
1081 if (descriptor.m_BiasEnabled)
1082 {
1083 // Defined supported types for bias
Sadik Armagandb73c982020-04-01 17:35:30 +0100[diff] [blame]1084 std::array<DataType, 5>
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1085 supportedBiasTypes =
1086 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1087 DataType::BFloat16,
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1088 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1089 DataType::Float16,
Sadik Armagandb73c982020-04-01 17:35:30 +0100[diff] [blame]1090 DataType::Signed32,
1091 DataType::QAsymmS8
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1092 };
1093
1094 supported &= CheckSupportRule(TypeAnyOf(biases, supportedBiasTypes), reasonIfUnsupported,
1095 "Reference Fully Connected: bias type not supported.");
1096
1097 supported &= CheckSupportRule(BiasAndWeightsTypesMatch(biases, weights), reasonIfUnsupported,
1098 "Reference Fully Connected: bias and weight types mismatch.");
1099
1100 supported &= CheckSupportRule(BiasAndWeightsTypesCompatible(weights, supportedBiasTypes), reasonIfUnsupported,
1101 "Reference Fully Connected: bias type inferred from weights is incompatible.");
1102
Narumol Prangnawarat366d7232020-04-29 12:58:17 +0100[diff] [blame]1103 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(biases, 1U), reasonIfUnsupported,
1104 "Reference Fully Connected: bias must have 1 dimension.");
1105
Francis Murtagh46c09d02019-05-28 08:15:28 +0100[diff] [blame]1106 }
1107
1108 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1109}
1110
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]1111bool RefLayerSupport::IsGatherSupported(const armnn::TensorInfo& input0,
1112 const armnn::TensorInfo& input1,
1113 const armnn::TensorInfo& output,
Teresa Charlin52664732020-06-29 16:27:03 +0100[diff] [blame]1114 const GatherDescriptor& descriptor,
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]1115 armnn::Optional<std::string&> reasonIfUnsupported) const
1116{
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]1117 bool supported = true;
Teresa Charlin3940d8b2020-05-29 16:47:23 +0100[diff] [blame]1118 std::array<DataType,7> supportedTypes =
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]1119 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1120 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1121 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1122 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1123 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1124 DataType::QAsymmU8,
Teresa Charlin3940d8b2020-05-29 16:47:23 +0100[diff] [blame]1125 DataType::QSymmS16,
1126 DataType::Signed32
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]1127 };
1128
Teresa Charlin52664732020-06-29 16:27:03 +0100[diff] [blame]1129 if (descriptor.m_Axis != 0)
1130 {
1131 reasonIfUnsupported.value() += std::string("Reference Gather: axis not supported\n");
1132 supported &= false;
1133 }
Ellen Norris-Thompsone0dbedf2019-06-24 09:23:38 +0100[diff] [blame]1134 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1135 "Reference Gather: input type not supported");
1136
1137 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1138 "Reference Gather: output type not supported");
1139
1140 supported &= CheckSupportRule(TypeIs(input1, DataType::Signed32), reasonIfUnsupported,
1141 "Reference Gather: indices (input1) type not supported");
1142
1143 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1144 "Reference Gather: input and output types not matching");
1145
1146 return supported;
narpra014951d842019-01-18 16:53:53 +0000[diff] [blame]1147}
1148
Derek Lamberti901ea112019-12-10 22:07:09 +0000[diff] [blame]1149bool RefLayerSupport::IsInputSupported(const TensorInfo& /*input*/,
1150 Optional<std::string&> /*reasonIfUnsupported*/) const
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1151{
Narumol Prangnawaratb6441e42019-06-04 11:22:00 +0100[diff] [blame]1152 return true;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1153}
1154
Kevin May09ca49c2019-10-09 12:37:34 +0100[diff] [blame]1155bool RefLayerSupport::IsInstanceNormalizationSupported(const TensorInfo& input,
1156 const TensorInfo& output,
1157 const InstanceNormalizationDescriptor& descriptor,
1158 Optional<std::string&> reasonIfUnsupported) const
1159{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1160 IgnoreUnused(descriptor);
Kevin May09ca49c2019-10-09 12:37:34 +0100[diff] [blame]1161 // Define supported types
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1162 std::array<DataType, 3> supportedTypes =
Kevin May09ca49c2019-10-09 12:37:34 +0100[diff] [blame]1163 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1164 DataType::BFloat16,
Kevin May09ca49c2019-10-09 12:37:34 +0100[diff] [blame]1165 DataType::Float32,
1166 DataType::Float16
1167 };
1168
1169 bool supported = true;
1170
1171 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1172 "Reference Instance Normalization: input type not supported.");
1173
1174 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1175 "Reference Instance Normalization: output type not supported.");
1176
1177 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1178 "Reference Instance Normalization: input and output types mismatched.");
1179
1180 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1181 "Reference Instance Normalization: input and output shapes have different "
1182 "num total elements.");
1183
1184 return supported;
1185}
1186
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1187bool RefLayerSupport::IsL2NormalizationSupported(const TensorInfo& input,
1188 const TensorInfo& output,
1189 const L2NormalizationDescriptor& descriptor,
1190 Optional<std::string&> reasonIfUnsupported) const
1191{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1192 IgnoreUnused(descriptor);
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1193 // Define supported types
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1194 std::array<DataType, 6> supportedTypes =
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1195 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1196 DataType::BFloat16,
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1197 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1198 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1199 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1200 DataType::QAsymmU8,
1201 DataType::QSymmS16
Ferran Balaguerd73d14f2019-06-10 10:29:54 +0100[diff] [blame]1202 };
1203
1204 bool supported = true;
1205
1206 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1207 "Reference L2normalization: input type not supported.");
1208
1209 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1210 "Reference L2normalization: output type not supported.");
1211
1212 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1213 "Reference L2normalization: input and output types mismatched.");
1214
1215 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1216 "Reference L2normalization: input and output shapes have different "
1217 "num total elements.");
1218
1219 return supported;
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1220}
1221
James Conroyaba90cd2020-11-06 16:28:18 +0000[diff] [blame]1222bool RefLayerSupport::IsLogicalBinarySupported(const TensorInfo& input0,
1223 const TensorInfo& input1,
1224 const TensorInfo& output,
1225 const LogicalBinaryDescriptor& descriptor,
1226 Optional<std::string&> reasonIfUnsupported) const
1227{
1228 IgnoreUnused(descriptor);
1229
1230 std::array<DataType, 1> supportedTypes =
1231 {
1232 DataType::Boolean
1233 };
1234
1235 bool supported = true;
1236 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1237 "Reference LogicalBinary: input 0 type not supported");
1238 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1239 "Reference LogicalBinary: input 1 type not supported");
1240
1241 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1242 "Reference LogicalBinary: input and output types do not match");
1243
1244 return supported;
1245}
1246
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1247bool RefLayerSupport::IsLogSoftmaxSupported(const TensorInfo& input,
1248 const TensorInfo& output,
1249 const LogSoftmaxDescriptor& descriptor,
1250 Optional<std::string&> reasonIfUnsupported) const
1251{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1252 IgnoreUnused(descriptor);
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1253
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1254 std::array<DataType, 3> supportedTypes =
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1255 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1256 DataType::BFloat16,
1257 DataType::Float32,
1258 DataType::Float16
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1259 };
1260
1261 bool supported = true;
1262 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1263 "Reference LogSoftmax: input type not supported");
1264
1265 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1266 "Reference LogSoftmax: output type not supported");
1267
1268 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1269 "Reference LogSoftmax: input and output types do not match");
1270
1271 return supported;
1272}
1273
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1274bool RefLayerSupport::IsLstmSupported(const TensorInfo& input,
1275 const TensorInfo& outputStateIn,
1276 const TensorInfo& cellStateIn,
1277 const TensorInfo& scratchBuffer,
1278 const TensorInfo& outputStateOut,
1279 const TensorInfo& cellStateOut,
1280 const TensorInfo& output,
1281 const LstmDescriptor& descriptor,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1282 const LstmInputParamsInfo& paramsInfo,
1283 Optional<std::string&> reasonIfUnsupported) const
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]1284{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1285 IgnoreUnused(descriptor);
1286 IgnoreUnused(paramsInfo);
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1287
1288 bool supported = true;
1289
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1290 std::array<DataType,3> supportedTypes = {
1291 DataType::BFloat16,
Conor Kennedyb9971c92019-05-07 07:14:23 +0100[diff] [blame]1292 DataType::Float32,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1293 DataType::QSymmS16
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1294 };
1295
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1296 // check inputs and outputs
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1297 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1298 "Reference Lstm: input is not a supported type.");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1299 supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
1300 "Reference Lstm: input and outputStateIn types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1301 supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
1302 "Reference Lstm: input and cellStateIn types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1303 supported &= CheckSupportRule(TypesAreEqual(input, scratchBuffer), reasonIfUnsupported,
1304 "Reference Lstm: input and scratchBuffer types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1305 supported &= CheckSupportRule(TypesAreEqual(input, outputStateOut), reasonIfUnsupported,
1306 "Reference Lstm: input and outputStateOut types are mismatched");
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1307 supported &= CheckSupportRule(TypesAreEqual(input, cellStateOut), reasonIfUnsupported,
1308 "Reference Lstm: input and cellStateOut types are mismatched");
Narumol Prangnawarate5339e72021-07-28 17:33:28 +0100[diff] [blame]1309
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1310 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1311 "Reference Lstm: input and output types are mismatched");
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1312 // check layer parameters
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1313 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1314 "Reference Lstm: input and InputToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1315 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToCellWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1316 "Reference Lstm: input and InputToCellWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1317 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1318 "Reference Lstm: input and InputToOutputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1319 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1320 "Reference Lstm: input and RecurrentToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1321 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToCellWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1322 "Reference Lstm: input and RecurrentToCellWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1323 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1324 "Reference Lstm: input and RecurrentToOutputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1325 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1326 "Reference Lstm: input and ForgetGateBias types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1327 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1328 "Reference Lstm: input and CellBias types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1329 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1330 "Reference Lstm: input and OutputGateBias types are mismatched");
1331 if (!descriptor.m_CifgEnabled)
1332 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1333 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputToInputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1334 "Reference Lstm: input and InputToInputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1335 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetRecurrentToInputWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1336 reasonIfUnsupported,
1337 "Reference Lstm: input and RecurrentToInputWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1338 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1339 "Reference Lstm: input and InputGateBias types are mismatched");
1340 if (descriptor.m_PeepholeEnabled)
1341 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1342 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToInputWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1343 reasonIfUnsupported,
1344 "Reference Lstm: input and CellToInputWeights types are mismatched");
1345 }
1346 }
1347 if (descriptor.m_PeepholeEnabled)
1348 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1349 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToForgetWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1350 "Reference Lstm: input and CellToForgetWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1351 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellToOutputWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1352 "Reference Lstm: input and CellToOutputWeights types are mismatched");
1353 }
1354 if (descriptor.m_ProjectionEnabled)
1355 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1356 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionWeights()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1357 "Reference Lstm: input and mProjectionWeights types are mismatched");
1358 if (paramsInfo.m_ProjectionBias != nullptr)
1359 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1360 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1361 "Reference Lstm: input and ProjectionBias types are mismatched");
1362 }
1363 }
1364 if (descriptor.m_LayerNormEnabled)
1365 {
1366 if (!descriptor.m_CifgEnabled)
1367 {
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1368 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1369 reasonIfUnsupported,
1370 "Reference Lstm: input and InputLayerNormWeights types are mismatched");
1371 }
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1372 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1373 reasonIfUnsupported,
1374 "Reference Lstm: input and ForgetLayerNormWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1375 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1376 reasonIfUnsupported,
1377 "Reference Lstm: input and CellLayerNormWeights types are mismatched");
Francis Murtaghbb590b42019-08-14 09:51:36 +0100[diff] [blame]1378 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputLayerNormWeights()),
Jan Eilersd01a83c2019-07-03 18:20:40 +0100[diff] [blame]1379 reasonIfUnsupported,
1380 "Reference Lstm: input and OutputLayerNormWeights types are mismatched");
1381 }
Nattapat Chaimanowongeb2b3292019-05-07 12:02:30 +0100[diff] [blame]1382
1383 return supported;
telsoa01c577f2c2018-08-31 09:22:23 +0100[diff] [blame]1384}
1385
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]1386bool RefLayerSupport::IsMaximumSupported(const TensorInfo& input0,
1387 const TensorInfo& input1,
1388 const TensorInfo& output,
1389 Optional<std::string&> reasonIfUnsupported) const
1390{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1391 bool supported = true;
1392
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1393 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1394 DataType::BFloat16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1395 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1396 DataType::Float16,
Keith Davis67e6c542020-02-19 10:08:33 +0000[diff] [blame]1397 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1398 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1399 DataType::QSymmS16,
1400 DataType::Signed32
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1401 };
1402
1403 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1404 "Reference maximum: input 0 is not a supported type.");
1405
1406 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1407 "Reference maximum: input 1 is not a supported type.");
1408
1409 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1410 "Reference maximum: output is not a supported type.");
1411
1412 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1413 "Reference maximum: input 0 and Input 1 types are mismatched");
1414
1415 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1416 "Reference maximum: input and output types are mismatched");
1417
1418 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1419 "Reference maximum: shapes are not suitable for implicit broadcast.");
1420
1421 return supported;
saoste012df12b32018-11-28 16:57:20 +0000[diff] [blame]1422}
1423
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1424bool RefLayerSupport::IsMeanSupported(const TensorInfo& input,
1425 const TensorInfo& output,
1426 const MeanDescriptor& descriptor,
1427 Optional<std::string&> reasonIfUnsupported) const
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]1428{
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1429 bool supported = true;
1430 std::string meanLayerStr = "Mean";
1431 std::string outputTensorStr = "output";
1432
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1433 std::array<DataType,6> supportedTypes =
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1434 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1435 DataType::BFloat16,
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1436 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1437 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1438 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1439 DataType::QAsymmU8,
1440 DataType::QSymmS16
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1441 };
1442
1443 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1444 "Reference Mean: input type not supported.");
1445
1446 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1447 "Reference Mean: input and output types are mismatched");
1448
1449 if (descriptor.m_KeepDims)
1450 {
1451 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, input.GetNumDimensions()),
1452 reasonIfUnsupported,
1453 CreateIncorrectDimensionsErrorMsg(input.GetNumDimensions(),
1454 output.GetNumDimensions(),
1455 meanLayerStr, outputTensorStr).data());
1456 }
1457 else if (descriptor.m_Axis.empty())
1458 {
1459 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1460 reasonIfUnsupported,
1461 CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1462 meanLayerStr, outputTensorStr).data());
1463 }
1464 else
1465 {
Matthew Sloyan171214c2020-09-09 09:07:37 +0100[diff] [blame]1466 auto outputDim = input.GetNumDimensions() - armnn::numeric_cast<unsigned int>(descriptor.m_Axis.size());
James Conroy4d1ff582019-06-10 17:06:39 +0100[diff] [blame]1467
1468 if (outputDim > 0)
1469 {
1470 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, outputDim),
1471 reasonIfUnsupported,
1472 CreateIncorrectDimensionsErrorMsg(outputDim, output.GetNumDimensions(),
1473 meanLayerStr, outputTensorStr).data());
1474 }
1475 else
1476 {
1477 supported &= CheckSupportRule(TensorNumDimensionsAreCorrect(output, 1),
1478 reasonIfUnsupported,
1479 CreateIncorrectDimensionsErrorMsg(1, output.GetNumDimensions(),
1480 meanLayerStr, outputTensorStr).data());
1481 }
1482 }
1483
1484 return supported;
narpra0132b90462018-09-13 11:07:48 +0100[diff] [blame]1485}
1486
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1487bool RefLayerSupport::IsMemCopySupported(const TensorInfo &input,
1488 const TensorInfo &output,
1489 Optional<std::string &> reasonIfUnsupported) const
1490{
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1491 bool supported = true;
1492
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1493 std::array<DataType,7> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1494 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1495 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1496 DataType::Float32,
1497 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1498 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1499 DataType::QAsymmU8,
1500 DataType::QSymmS16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]1501 DataType::Boolean
1502 };
1503
1504 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1505 "Reference MemCopy: input type not supported");
1506
1507 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1508 "Reference MemCopy: output type not supported");
1509
1510 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1511 "Reference MemCopy: input and output types are mismatched");
1512
1513 return supported;
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1514}
1515
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]1516bool RefLayerSupport::IsMinimumSupported(const TensorInfo& input0,
1517 const TensorInfo& input1,
1518 const TensorInfo& output,
1519 Optional<std::string&> reasonIfUnsupported) const
1520{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1521 bool supported = true;
1522
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1523 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1524 DataType::BFloat16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1525 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1526 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1527 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1528 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1529 DataType::QSymmS16,
1530 DataType::Signed32
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1531 };
1532
1533 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1534 "Reference minimum: input 0 is not a supported type.");
1535
1536 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1537 "Reference minimum: input 1 is not a supported type.");
1538
1539 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1540 "Reference minimum: output is not a supported type.");
1541
1542 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1543 "Reference minimum: input 0 and Input 1 types are mismatched");
1544
1545 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1546 "Reference minimum: input and output types are mismatched");
1547
1548 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1549 "Reference minimum: shapes are not suitable for implicit broadcast.");
1550
1551 return supported;
Éanna Ó Catháin20e58802018-12-04 10:29:06 +0000[diff] [blame]1552}
1553
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1554bool RefLayerSupport::IsMultiplicationSupported(const TensorInfo& input0,
1555 const TensorInfo& input1,
1556 const TensorInfo& output,
1557 Optional<std::string&> reasonIfUnsupported) const
1558{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1559 bool supported = true;
1560
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1561 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1562 DataType::BFloat16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1563 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1564 DataType::Float16,
Keith Davis67e6c542020-02-19 10:08:33 +0000[diff] [blame]1565 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1566 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]1567 DataType::QSymmS16,
1568 DataType::Signed32
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]1569 };
1570
1571 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
1572 "Reference multiplication: input 0 is not a supported type.");
1573
1574 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
1575 "Reference multiplication: input 1 is not a supported type.");
1576
1577 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1578 "Reference multiplication: output is not a supported type.");
1579
1580 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
1581 "Reference multiplication: input 0 and Input 1 types are mismatched");
1582
1583 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
1584 "Reference multiplication: input and output types are mismatched");
1585
1586 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
1587 "Reference multiplication: shapes are not suitable for implicit broadcast.");
1588
1589 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1590}
1591
1592bool RefLayerSupport::IsNormalizationSupported(const TensorInfo& input,
1593 const TensorInfo& output,
1594 const NormalizationDescriptor& descriptor,
1595 Optional<std::string&> reasonIfUnsupported) const
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]1596{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1597 IgnoreUnused(descriptor);
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1598
1599 // Define supported types
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1600 std::array<DataType, 6> supportedTypes =
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1601 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1602 DataType::BFloat16,
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1603 DataType::Float16,
1604 DataType::Float32,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1605 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1606 DataType::QAsymmU8,
1607 DataType::QSymmS16
Matteo Martincigh2fc70c52019-06-05 14:12:48 +0100[diff] [blame]1608 };
1609
1610 bool supported = true;
1611
1612 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1613 "Reference normalization: input type not supported.");
1614
1615 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1616 "Reference normalization: output type not supported.");
1617
1618 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1619 "Reference normalization: input and output shapes have different "
1620 "num total elements.");
1621
1622 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1623}
1624
Derek Lamberti901ea112019-12-10 22:07:09 +0000[diff] [blame]1625bool RefLayerSupport::IsOutputSupported(const TensorInfo& /*output*/,
1626 Optional<std::string&> /*reasonIfUnsupported*/) const
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1627{
Narumol Prangnawaratb6441e42019-06-04 11:22:00 +0100[diff] [blame]1628 return true;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1629}
1630
1631bool RefLayerSupport::IsPadSupported(const TensorInfo& input,
1632 const TensorInfo& output,
1633 const PadDescriptor& descriptor,
1634 Optional<std::string&> reasonIfUnsupported) const
1635{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1636 IgnoreUnused(descriptor);
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1637 bool supported = true;
1638
1639 // Define supported output and inputs types.
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1640 std::array<DataType,6> supportedTypes =
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1641 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1642 DataType::BFloat16,
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1643 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1644 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1645 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1646 DataType::QAsymmU8,
1647 DataType::QSymmS16
Narumol Prangnawarate6eaf662019-07-08 08:57:17 +0100[diff] [blame]1648 };
1649
1650 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1651 "Reference pad: input is not a supported type.");
1652
1653 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1654 "Reference pad: output is not a supported type.");
1655
1656 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1657 "Reference pad: input and output types are mismatched.");
1658
1659 return supported;
Nina Drozd661dfa72018-10-02 11:14:17 +0100[diff] [blame]1660}
1661
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1662bool RefLayerSupport::IsPermuteSupported(const TensorInfo& input,
1663 const TensorInfo& output,
1664 const PermuteDescriptor& descriptor,
1665 Optional<std::string&> reasonIfUnsupported) const
1666{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1667 IgnoreUnused(descriptor);
Narumol Prangnawarat86bb4e12019-07-08 11:36:05 +0100[diff] [blame]1668 bool supported = true;
1669
1670 // Define supported output and inputs types.
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1671 std::array<DataType, 6> supportedTypes =
Narumol Prangnawarat86bb4e12019-07-08 11:36:05 +0100[diff] [blame]1672 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1673 DataType::BFloat16,
Narumol Prangnawarat86bb4e12019-07-08 11:36:05 +0100[diff] [blame]1674 DataType::Float32,
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]1675 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1676 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1677 DataType::QAsymmU8,
1678 DataType::QSymmS16
Narumol Prangnawarat86bb4e12019-07-08 11:36:05 +0100[diff] [blame]1679 };
1680
1681 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1682 "Reference permute: input is not a supported type.");
1683
1684 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1685 "Reference permute: output is not a supported type.");
1686
1687 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1688 "Reference permute: input and output types are mismatched.");
1689
1690 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1691}
1692
1693bool RefLayerSupport::IsPooling2dSupported(const TensorInfo& input,
1694 const TensorInfo& output,
1695 const Pooling2dDescriptor& descriptor,
1696 Optional<std::string&> reasonIfUnsupported) const
1697{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1698 IgnoreUnused(descriptor);
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1699 bool supported = true;
1700
1701 // Define supported output and inputs types.
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1702 std::array<DataType,6> supportedTypes =
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1703 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1704 DataType::BFloat16,
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1705 DataType::Float32,
Matthew Jackson252df3a2019-09-11 09:19:18 +0100[diff] [blame]1706 DataType::Float16,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]1707 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1708 DataType::QAsymmU8,
1709 DataType::QSymmS16
Teresa Charlina3b20472019-06-06 11:12:32 +0100[diff] [blame]1710 };
1711
1712 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1713 "Reference poolind2d: input is not a supported type.");
1714
1715 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1716 "Reference poolind2d: output is not a supported type.");
1717
1718 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1719 "Reference poolind2d: input and output types are mismatched.");
1720
1721 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1722}
1723
Tamás Nyíri7b885b32021-10-26 14:47:57 +0100[diff] [blame]1724bool RefLayerSupport::IsPooling3dSupported(const TensorInfo& input,
1725 const TensorInfo& output,
1726 const Pooling3dDescriptor& descriptor,
1727 Optional<std::string&> reasonIfUnsupported) const
1728{
1729 IgnoreUnused(descriptor);
1730 bool supported = true;
1731
1732 // Define supported output and inputs types.
1733 std::array<DataType,6> supportedTypes =
1734 {
1735 DataType::BFloat16,
1736 DataType::Float32,
1737 DataType::Float16,
1738 DataType::QAsymmS8,
1739 DataType::QAsymmU8,
1740 DataType::QSymmS16
1741 };
1742
1743 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1744 "Reference poolind3d: input is not a supported type.");
1745
1746 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1747 "Reference poolind3d: output is not a supported type.");
1748
1749 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1750 "Reference poolind3d: input and output types are mismatched.");
1751
1752 return supported;
1753}
1754
1755
James Conroy4f1f8992020-04-29 20:01:10 +0100[diff] [blame]1756bool RefLayerSupport::IsQLstmSupported(const TensorInfo& input,
1757 const TensorInfo& previousOutputIn,
1758 const TensorInfo& previousCellStateIn,
1759 const TensorInfo& outputStateOut,
1760 const TensorInfo& cellStateOut,
1761 const TensorInfo& output,
1762 const QLstmDescriptor& descriptor,
1763 const LstmInputParamsInfo& paramsInfo,
1764 Optional<std::string&> reasonIfUnsupported) const
1765{
1766 IgnoreUnused(input);
1767 IgnoreUnused(previousOutputIn);
1768 IgnoreUnused(previousCellStateIn);
1769 IgnoreUnused(outputStateOut);
1770 IgnoreUnused(cellStateOut);
1771 IgnoreUnused(output);
1772 IgnoreUnused(descriptor);
1773 IgnoreUnused(paramsInfo);
1774
1775 IgnoreUnused(reasonIfUnsupported);
1776
1777 return true;
1778}
1779
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]1780bool RefLayerSupport::IsQuantizeSupported(const TensorInfo& input,
1781 const TensorInfo& output,
1782 Optional<std::string&> reasonIfUnsupported) const
1783{
1784 bool supported = true;
1785
Finn Williamsfd271062019-12-04 14:27:27 +0000[diff] [blame]1786 // Define supported input types.
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1787 std::array<DataType,7> supportedInputTypes = {
1788 DataType::BFloat16,
Keith Davis5e51cd82020-01-29 16:52:59 +0000[diff] [blame]1789 DataType::Float32,
Keith Davis3d8bc972020-02-04 09:31:47 +0000[diff] [blame]1790 DataType::Float16,
Ryan OShea9add1202020-02-07 10:06:33 +0000[diff] [blame]1791 DataType::QAsymmS8,
Keith Davis5e51cd82020-01-29 16:52:59 +0000[diff] [blame]1792 DataType::QAsymmU8,
1793 DataType::QSymmS8,
1794 DataType::QSymmS16
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]1795 };
1796
1797 supported &= CheckSupportRule(TypeAnyOf(input, supportedInputTypes), reasonIfUnsupported,
1798 "Reference quantize: input type not supported.");
1799
1800 // Define supported output types.
Ryan OShea9add1202020-02-07 10:06:33 +0000[diff] [blame]1801 std::array<DataType,4> supportedOutputTypes = {
Ryan OShea9add1202020-02-07 10:06:33 +0000[diff] [blame]1802 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1803 DataType::QAsymmU8,
Finn Williamsfd271062019-12-04 14:27:27 +0000[diff] [blame]1804 DataType::QSymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1805 DataType::QSymmS16
Derek Lamberti5f400d62019-03-25 15:41:58 +0000[diff] [blame]1806 };
1807 supported &= CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1808 "Reference quantize: output type not supported.");
1809
1810 supported &= CheckSupportRule(ShapesAreSameTotalSize(input, output), reasonIfUnsupported,
1811 "Reference quantize: input and output shapes have different num total elements.");
1812
1813 return supported;
1814}
1815
Finn Williams2605b232020-06-10 15:53:46 +0100[diff] [blame]1816bool RefLayerSupport::IsRankSupported(const TensorInfo& input,
1817 const TensorInfo& output,
1818 Optional<std::string&> reasonIfUnsupported) const
1819{
1820 IgnoreUnused(input);
1821 // Define supported output types.
1822 std::array<DataType,1> supportedOutputTypes =
1823 {
1824 DataType::Signed32,
1825 };
1826
1827 return CheckSupportRule(TypeAnyOf(output, supportedOutputTypes), reasonIfUnsupported,
1828 "Reference rank: input type not supported.");
1829}
1830
Sadik Armagan0c3ea5b2021-02-03 09:29:30 +0000[diff] [blame]1831bool RefLayerSupport::IsReduceSupported(const TensorInfo& input,
1832 const TensorInfo& output,
1833 const ReduceDescriptor& descriptor,
1834 Optional<std::string&> reasonIfUnsupported) const
1835{
1836 IgnoreUnused(descriptor);
1837 bool supported = true;
1838 std::array<DataType,7> supportedTypes =
1839 {
1840 DataType::BFloat16,
1841 DataType::Float32,
1842 DataType::Float16,
1843 DataType::QAsymmS8,
1844 DataType::QAsymmU8,
1845 DataType::QSymmS16,
1846 DataType::Signed32
1847 };
1848
1849 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1850 "Reference Reduce: input type not supported");
1851
1852 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1853 "Reference Reduce: output type not supported");
1854
1855 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1856 "Reference Reduce: input and output types not matching");
1857
1858 return supported;
1859}
1860
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1861bool RefLayerSupport::IsReshapeSupported(const TensorInfo& input,
Kevin Maya023c402019-12-12 17:28:05 +0000[diff] [blame]1862 const TensorInfo& output,
Matteo Martincigh992d6dc2019-01-10 17:34:20 +0000[diff] [blame]1863 const ReshapeDescriptor& descriptor,
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1864 Optional<std::string&> reasonIfUnsupported) const
1865{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1866 IgnoreUnused(output);
1867 IgnoreUnused(descriptor);
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1868 // Define supported output types.
Narumol Prangnawarat0c95f4c2020-11-18 16:52:07 +0000[diff] [blame]1869 std::array<DataType,8> supportedOutputTypes =
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1870 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1871 DataType::BFloat16,
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1872 DataType::Float32,
1873 DataType::Float16,
Narumol Prangnawarat0718ee92019-09-13 16:53:38 +0100[diff] [blame]1874 DataType::Signed32,
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]1875 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1876 DataType::QAsymmU8,
Narumol Prangnawarat0c95f4c2020-11-18 16:52:07 +0000[diff] [blame]1877 DataType::QSymmS16,
1878 DataType::Boolean
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1879 };
Keith Davis0c2eeac2020-02-11 16:51:50 +0000[diff] [blame]1880
Nina Drozd2f2778f2019-05-27 10:37:05 +0100[diff] [blame]1881 return CheckSupportRule(TypeAnyOf(input, supportedOutputTypes), reasonIfUnsupported,
1882 "Reference reshape: input type not supported.");
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1883}
1884
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1885bool RefLayerSupport::IsResizeSupported(const TensorInfo& input,
1886 const TensorInfo& output,
1887 const ResizeDescriptor& descriptor,
1888 Optional<std::string&> reasonIfUnsupported) const
1889{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1890 IgnoreUnused(descriptor);
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1891 bool supported = true;
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1892 std::array<DataType,6> supportedTypes =
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1893 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1894 DataType::BFloat16,
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1895 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]1896 DataType::Float16,
Keith Davis67e6c542020-02-19 10:08:33 +0000[diff] [blame]1897 DataType::QAsymmS8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1898 DataType::QAsymmU8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1899 DataType::QSymmS16
Teresa Charlin970f43b2019-07-01 13:51:07 +0100[diff] [blame]1900 };
1901
1902 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1903 "Reference Resize: input type not supported");
1904
1905 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1906 "Reference Resize: output type not supported");
1907
1908 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1909 "Reference Resize: input and output types not matching");
1910
1911 return supported;
1912}
1913
Keith Davis3ae3f972021-05-21 16:33:48 +0100[diff] [blame]1914bool RefLayerSupport::IsShapeSupported(const TensorInfo& input,
1915 const TensorInfo& output,
1916 Optional<std::string&> reasonIfUnsupported) const
1917{
1918 IgnoreUnused(input);
1919 bool supported = true;
1920
1921 std::array<DataType, 1> supportedTypes =
1922 {
1923 DataType::Signed32
1924 };
1925
1926 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1927 "Reference Shape: output type not supported");
1928
1929 return supported;
1930}
1931
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1932bool RefLayerSupport::IsSliceSupported(const TensorInfo& input,
1933 const TensorInfo& output,
1934 const SliceDescriptor& descriptor,
1935 Optional<std::string&> reasonIfUnsupported) const
1936{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1937 IgnoreUnused(descriptor);
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1938 bool supported = true;
1939
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1940 std::array<DataType, 5> supportedTypes =
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1941 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1942 DataType::BFloat16,
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1943 DataType::Float32,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1944 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]1945 DataType::QAsymmU8,
1946 DataType::QSymmS16
Aron Virginas-Tar92b9f872019-09-17 17:27:04 +0100[diff] [blame]1947 };
1948
1949 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
1950 "Reference Slice: input type not supported");
1951
1952 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
1953 "Reference Slice: output type not supported");
1954
1955 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
1956 "Reference Slice: input and output types are mismatched");
1957
1958 return supported;
1959}
1960
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1961bool RefLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
1962 const TensorInfo& output,
1963 const SoftmaxDescriptor& descriptor,
1964 Optional<std::string&> reasonIfUnsupported) const
1965{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1966 IgnoreUnused(descriptor);
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1967 bool supported = true;
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1968 std::array<DataType,7> supportedTypes =
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1969 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]1970 DataType::BFloat16,
1971 DataType::Float32,
1972 DataType::Float16,
1973 DataType::QSymmS8,
1974 DataType::QAsymmS8,
1975 DataType::QAsymmU8,
1976 DataType::QSymmS16
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1977 };
1978
1979 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1980 "Reference Softmax: output type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1981
1982 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1983 "Reference Softmax: input type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1984
1985 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
Aron Virginas-Tare662a942019-10-14 15:12:00 +0100[diff] [blame]1986 "Reference Softmax: input type not supported");
nikraj01248683f2019-05-29 16:46:50 +0100[diff] [blame]1987
1988 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]1989}
1990
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]1991bool RefLayerSupport::IsSpaceToBatchNdSupported(const TensorInfo& input,
1992 const TensorInfo& output,
1993 const SpaceToBatchNdDescriptor& descriptor,
1994 Optional<std::string&> reasonIfUnsupported) const
1995{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]1996 IgnoreUnused(descriptor);
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1997 bool supported = true;
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]1998 std::array<DataType,6> supportedTypes =
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]1999 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2000 DataType::BFloat16,
2001 DataType::Float32,
2002 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2003 DataType::QAsymmS8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2004 DataType::QAsymmU8,
2005 DataType::QSymmS16
nikraj01120522a2019-05-31 11:33:07 +0100[diff] [blame]2006 };
2007
2008 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2009 "Reference SpaceToBatchNd: input type not supported");
2010
2011 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2012 "Reference SpaceToBatchNd: output type not supported");
2013
2014 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2015 "Reference SpaceToBatchNd: input and output types are mismatched");
2016
2017 return supported;
Nattapat Chaimanowong3ea76d52018-11-09 14:10:38 +0000[diff] [blame]2018}
2019
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2020bool RefLayerSupport::IsSpaceToDepthSupported(const TensorInfo& input,
Keith Davis51910332019-06-26 15:28:43 +0100[diff] [blame]2021 const TensorInfo& output,
2022 const SpaceToDepthDescriptor& descriptor,
2023 Optional<std::string&> reasonIfUnsupported) const
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2024{
2025
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2026 IgnoreUnused(descriptor);
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2027 bool supported = true;
2028
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2029 std::array<DataType,6> supportedTypes =
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2030 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2031 DataType::BFloat16,
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2032 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]2033 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2034 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2035 DataType::QAsymmU8,
2036 DataType::QSymmS16
Keith Davisa57eccb2019-06-14 17:33:22 +0100[diff] [blame]2037 };
2038
2039 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2040 "Reference SpaceToDepth: input type not supported");
2041
2042 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2043 "Reference SpaceToDepth: output type not supported");
2044
2045 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2046 "Reference SpaceToDepth: input and output types are mismatched");
2047
2048 return supported;
2049}
2050
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]2051bool RefLayerSupport::IsSplitterSupported(const TensorInfo& input,
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]2052 const std::vector<std::reference_wrapper<TensorInfo>>& outputs,
2053 const ViewsDescriptor& descriptor,
2054 Optional<std::string&> reasonIfUnsupported) const
2055{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2056 IgnoreUnused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2057 bool supported = true;
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2058 std::array<DataType,6> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2059 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2060 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2061 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]2062 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2063 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2064 DataType::QAsymmU8,
2065 DataType::QSymmS16
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2066 };
2067
2068 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2069 "Reference splitter: output type not supported");
Derek Lambertieac4adb2020-08-25 13:05:59 +0100[diff] [blame]2070 for (const TensorInfo& output : outputs)
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2071 {
2072 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2073 "Reference splitter: input type not supported");
2074
2075 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2076 "Reference splitter: input and output types mismatched.");
2077 }
2078
2079 return supported;
Narumol Prangnawarat15eb5832019-05-20 15:31:05 +0100[diff] [blame]2080}
2081
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2082bool RefLayerSupport::IsStackSupported(const std::vector<const TensorInfo*>& inputs,
2083 const TensorInfo& output,
2084 const StackDescriptor& descriptor,
2085 Optional<std::string&> reasonIfUnsupported) const
2086{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2087 IgnoreUnused(descriptor);
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2088
2089 bool supported = true;
Sadik Armagan529195f2022-01-14 12:56:35 +0000[diff] [blame^]2090 std::array<DataType,7> supportedTypes =
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2091 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2092 DataType::BFloat16,
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2093 DataType::Float32,
Matthew Jacksone69c3992019-09-09 14:31:21 +0100[diff] [blame]2094 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2095 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2096 DataType::QAsymmU8,
Sadik Armagan529195f2022-01-14 12:56:35 +0000[diff] [blame^]2097 DataType::QSymmS16,
2098 DataType::Signed32
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2099 };
2100
2101 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2102 "Reference stack: output type not supported");
2103 for (const TensorInfo* input : inputs)
2104 {
Narumol Prangnawaratac2770a2020-04-01 16:51:23 +0100[diff] [blame]2105 ARMNN_ASSERT(input != nullptr);
Matthew Jackson81e601c2019-07-11 12:07:09 +0100[diff] [blame]2106 supported &= CheckSupportRule(TypeAnyOf(*input, supportedTypes), reasonIfUnsupported,
2107 "Reference stack: input type not supported");
2108
2109 supported &= CheckSupportRule(TypesAreEqual(*input, output), reasonIfUnsupported,
2110 "Reference stack: input and output types mismatched.");
2111 }
2112
2113 return supported;
2114}
2115
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]2116bool RefLayerSupport::IsStridedSliceSupported(const TensorInfo& input,
2117 const TensorInfo& output,
2118 const StridedSliceDescriptor& descriptor,
2119 Optional<std::string&> reasonIfUnsupported) const
2120{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2121 IgnoreUnused(descriptor);
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2122 bool supported = true;
2123
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2124 std::array<DataType,5> supportedTypes =
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2125 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2126 DataType::BFloat16,
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2127 DataType::Float32,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2128 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2129 DataType::QAsymmU8,
2130 DataType::QSymmS16
Narumol Prangnawaratf9ac3fd2019-07-03 14:55:57 +0100[diff] [blame]2131 };
2132
2133 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2134 "Reference StridedSlice: input type not supported");
2135
2136 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2137 "Reference StridedSlice: output type not supported");
2138
2139 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2140 "Reference StridedSlice: input and output types are mismatched");
2141
2142 return supported;
Nattapat Chaimanowong1216b582018-11-23 15:33:41 +0000[diff] [blame]2143}
2144
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]2145bool RefLayerSupport::IsSubtractionSupported(const TensorInfo& input0,
2146 const TensorInfo& input1,
2147 const TensorInfo& output,
2148 Optional<std::string&> reasonIfUnsupported) const
2149{
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]2150 bool supported = true;
2151
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]2152 std::array<DataType,7> supportedTypes = {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2153 DataType::BFloat16,
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]2154 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]2155 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2156 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2157 DataType::QAsymmU8,
Teresa Charlinecb6b8e2020-05-22 18:08:23 +0100[diff] [blame]2158 DataType::QSymmS16,
2159 DataType::Signed32
Sadik Armagan2999a022019-04-09 14:20:12 +0100[diff] [blame]2160 };
2161
2162 supported &= CheckSupportRule(TypeAnyOf(input0, supportedTypes), reasonIfUnsupported,
2163 "Reference subtraction: input 0 is not a supported type.");
2164
2165 supported &= CheckSupportRule(TypeAnyOf(input1, supportedTypes), reasonIfUnsupported,
2166 "Reference subtraction: input 1 is not a supported type.");
2167
2168 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2169 "Reference subtraction: output is not a supported type.");
2170
2171 supported &= CheckSupportRule(TypesAreEqual(input0, input1), reasonIfUnsupported,
2172 "Reference subtraction: input 0 and Input 1 types are mismatched");
2173
2174 supported &= CheckSupportRule(TypesAreEqual(input0, output), reasonIfUnsupported,
2175 "Reference subtraction: input and output types are mismatched");
2176
2177 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input0, input1, output), reasonIfUnsupported,
2178 "Reference subtraction: shapes are not suitable for implicit broadcast.");
2179
2180 return supported;
Aron Virginas-Tarb5acbb72018-10-15 11:11:51 +0100[diff] [blame]2181}
2182
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]2183bool RefLayerSupport::IsPreluSupported(const TensorInfo& input,
2184 const TensorInfo& alpha,
2185 const TensorInfo& output,
2186 Optional<std::string&> reasonIfUnsupported) const
2187{
2188 bool supported = true;
2189
Teresa Charlin3940d8b2020-05-29 16:47:23 +0100[diff] [blame]2190 std::array<DataType, 6> supportedTypes
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]2191 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2192 DataType::BFloat16,
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]2193 DataType::Float32,
Matthew Jackson9bff1442019-09-12 09:08:23 +0100[diff] [blame]2194 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2195 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2196 DataType::QAsymmU8,
Teresa Charlin3940d8b2020-05-29 16:47:23 +0100[diff] [blame]2197 DataType::QSymmS16
Matteo Martincighab9e5252019-06-13 17:27:46 +0100[diff] [blame]2198 };
2199
2200 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2201 "PReLU: input is not a supported type.");
2202
2203 supported &= CheckSupportRule(TypeAnyOf(alpha, supportedTypes), reasonIfUnsupported,
2204 "PReLU: alpha is not a supported type.");
2205
2206 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2207 "PReLU: output is not a supported type.");
2208
2209 supported &= CheckSupportRule(TypesAreEqual(input, alpha, output), reasonIfUnsupported,
2210 "PReLU: input, alpha and output types are mismatched");
2211
2212 supported &= CheckSupportRule(ShapesAreBroadcastCompatible(input, alpha, output), reasonIfUnsupported,
2213 "PReLU: shapes are not suitable for implicit broadcast");
2214
2215 return supported;
2216}
2217
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2218bool RefLayerSupport::IsTransposeConvolution2dSupported(const TensorInfo& input,
2219 const TensorInfo& output,
2220 const TransposeConvolution2dDescriptor& descriptor,
2221 const TensorInfo& weights,
2222 const Optional<TensorInfo>& biases,
2223 Optional<std::string&> reasonIfUnsupported) const
2224{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2225 IgnoreUnused(descriptor);
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2226 bool supported = true;
2227
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2228 std::array<DataType,7> supportedTypes =
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2229 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2230 DataType::BFloat16,
2231 DataType::Float32,
2232 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2233 DataType::QAsymmS8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2234 DataType::QAsymmU8,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2235 DataType::QSymmS8,
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2236 DataType::QSymmS16
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2237 };
2238
2239 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2240 "Reference TransposeConvolution2d: input is not a supported type.");
2241
2242 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2243 "Reference TransposeConvolution2d: output is not a supported type.");
2244
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2245 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2246 "Reference TransposeConvolution2d: input and output types mismatched.");
2247
Aron Virginas-Tar94d3b932019-11-11 12:54:47 +0000[diff] [blame]2248
2249 const DataType inputType = input.GetDataType();
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2250 if (IsQuantized8BitType(inputType))
Aron Virginas-Tar94d3b932019-11-11 12:54:47 +0000[diff] [blame]2251 {
Jan Eilers1b2654f2021-09-24 15:45:46 +0100[diff] [blame]2252 std::array<DataType, 3> supportedWeightTypes =
Aron Virginas-Tar94d3b932019-11-11 12:54:47 +0000[diff] [blame]2253 {
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2254 DataType::QAsymmS8,
Derek Lambertif90c56d2020-01-10 17:14:08 +0000[diff] [blame]2255 DataType::QAsymmU8,
Jan Eilers1b2654f2021-09-24 15:45:46 +0100[diff] [blame]2256 DataType::QSymmS8
Aron Virginas-Tar94d3b932019-11-11 12:54:47 +0000[diff] [blame]2257 };
2258
2259 supported &= CheckSupportRule(TypeAnyOf(weights, supportedWeightTypes), reasonIfUnsupported,
2260 "Reference TransposeConvolution2d: weights type not supported for "
2261 "quantized input.");
2262 }
2263 else
2264 {
2265 supported &= CheckSupportRule(TypeAnyOf(weights, supportedTypes), reasonIfUnsupported,
2266 "Reference TransposeConvolution2d: weights is not a supported type.");
2267
2268 supported &= CheckSupportRule(TypesAreEqual(input, weights), reasonIfUnsupported,
2269 "Reference TransposeConvolution2d: input and weights types mismatched.");
2270 }
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2271
2272 if (biases.has_value())
2273 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2274 std::array<DataType,4> biasesSupportedTypes =
Aron Virginas-Tar651aafe2019-08-05 11:52:05 +0100[diff] [blame]2275 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2276 DataType::BFloat16,
2277 DataType::Float32,
2278 DataType::Float16,
2279 DataType::Signed32
Aron Virginas-Tar98180ef2019-06-26 15:02:47 +0100[diff] [blame]2280 };
2281 supported &= CheckSupportRule(TypeAnyOf(biases.value(), biasesSupportedTypes), reasonIfUnsupported,
2282 "Reference TransposeConvolution2d: biases is not a supported type.");
2283 }
2284
2285 return supported;
2286}
2287
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]2288bool RefLayerSupport::IsTransposeSupported(const TensorInfo& input,
2289 const TensorInfo& output,
2290 const TransposeDescriptor& descriptor,
2291 Optional<std::string&> reasonIfUnsupported) const
2292{
Jan Eilers8eb25602020-03-09 12:13:48 +0000[diff] [blame]2293 IgnoreUnused(descriptor);
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]2294 bool supported = true;
2295
2296 // Define supported output and inputs types.
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2297 std::array<DataType, 6> supportedTypes =
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]2298 {
Narumol Prangnawarat44179c32020-03-11 14:51:27 +0000[diff] [blame]2299 DataType::BFloat16,
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]2300 DataType::Float32,
2301 DataType::Float16,
Sadik Armagan303980c2020-04-17 12:45:14 +0100[diff] [blame]2302 DataType::QAsymmS8,
Mike Kellyc9ea45a2020-02-28 18:11:58 +0000[diff] [blame]2303 DataType::QAsymmU8,
2304 DataType::QSymmS16
2305 };
2306
2307 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2308 "Reference transpose: input is not a supported type.");
2309
2310 supported &= CheckSupportRule(TypeAnyOf(output, supportedTypes), reasonIfUnsupported,
2311 "Reference transpose: output is not a supported type.");
2312
2313 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2314 "Reference transpose: input and output types are mismatched.");
2315
2316 return supported;
2317}
2318
Narumol Prangnawarate5339e72021-07-28 17:33:28 +0100[diff] [blame]2319bool RefLayerSupport::IsUnidirectionalSequenceLstmSupported(
2320 const TensorInfo& input,
2321 const TensorInfo& outputStateIn,
2322 const TensorInfo& cellStateIn,
2323 const TensorInfo& output,
2324 const Optional<TensorInfo>& hiddenStateOutput,
2325 const Optional<TensorInfo>& cellStateOutput,
2326 const UnidirectionalSequenceLstmDescriptor& descriptor,
2327 const LstmInputParamsInfo& paramsInfo,
2328 Optional<std::string&> reasonIfUnsupported) const
2329{
2330 IgnoreUnused(descriptor);
2331 IgnoreUnused(paramsInfo);
2332 IgnoreUnused(outputStateIn);
2333 IgnoreUnused(cellStateIn);
2334 bool supported = true;
2335
2336 if (hiddenStateOutput.has_value() || cellStateOutput.has_value())
2337 {
2338 reasonIfUnsupported.value() += "Reference UnidirectionalSequenceLstm: hidden state output "
2339 "and cell state output are not supported at the moment.";
2340 }
2341
2342 std::array<DataType, 1> supportedTypes =
2343 {
2344 DataType::Float32
2345 };
2346
Narumol Prangnawaratbd575b22021-08-31 16:53:54 +0100[diff] [blame]2347 std::array<DataType, 2> supportedWeightTypes =
Narumol Prangnawarate5339e72021-07-28 17:33:28 +0100[diff] [blame]2348 {
Narumol Prangnawaratbd575b22021-08-31 16:53:54 +0100[diff] [blame]2349 DataType::Float32,
2350 DataType::QAsymmS8
Narumol Prangnawarate5339e72021-07-28 17:33:28 +0100[diff] [blame]2351 };
2352
2353 // check inputs and outputs
2354 supported &= CheckSupportRule(TypeAnyOf(input, supportedTypes), reasonIfUnsupported,
2355 "Reference UnidirectionalSequenceLstm: input is not a supported type.");
2356 supported &= CheckSupportRule(TypesAreEqual(input, outputStateIn), reasonIfUnsupported,
2357 "Reference UnidirectionalSequenceLstm: input and outputStateIn types are mismatched");
2358 supported &= CheckSupportRule(TypesAreEqual(input, cellStateIn), reasonIfUnsupported,
2359 "Reference UnidirectionalSequenceLstm: input and cellStateIn types are mismatched");
2360
2361 supported &= CheckSupportRule(TypesAreEqual(input, output), reasonIfUnsupported,
2362 "Reference UnidirectionalSequenceLstm: input and output types are mismatched");
2363 // check layer parameters
2364 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToForgetWeights(), supportedWeightTypes),
2365 reasonIfUnsupported,
2366 "Reference UnidirectionalSequenceLstm: InputToForgetWeights "
2367 "is not a supported type.");
2368 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToCellWeights(), supportedWeightTypes),
2369 reasonIfUnsupported,
2370 "Reference UnidirectionalSequenceLstm: InputToCellWeights is not a supported type.");
2371 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToOutputWeights(), supportedWeightTypes),
2372 reasonIfUnsupported,
2373 "Reference UnidirectionalSequenceLstm: InputToOutputWeights "
2374 "is not a supported type.");
2375 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToForgetWeights(), supportedWeightTypes),
2376 reasonIfUnsupported,
2377 "Reference UnidirectionalSequenceLstm: RecurrentToForgetWeights "
2378 "is not a supported type.");
2379 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToCellWeights(), supportedWeightTypes),
2380 reasonIfUnsupported,
2381 "Reference UnidirectionalSequenceLstm: RecurrentToCellWeights "
2382 "is not a supported type.");
2383 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToOutputWeights(), supportedWeightTypes),
2384 reasonIfUnsupported,
2385 "Reference UnidirectionalSequenceLstm: RecurrentToOutputWeights "
2386 "is not a supported type.");
2387 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetForgetGateBias()), reasonIfUnsupported,
2388 "Reference UnidirectionalSequenceLstm: input and ForgetGateBias types "
2389 "are mismatched");
2390 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetCellBias()), reasonIfUnsupported,
2391 "Reference UnidirectionalSequenceLstm: input and CellBias types are mismatched");
2392 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetOutputGateBias()), reasonIfUnsupported,
2393 "Reference UnidirectionalSequenceLstm: input and OutputGateBias types "
2394 "are mismatched");
2395 if (!descriptor.m_CifgEnabled)
2396 {
2397 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputToInputWeights(), supportedWeightTypes),
2398 reasonIfUnsupported,
2399 "Reference UnidirectionalSequenceLstm: InputToInputWeights "
2400 "is not a supported type.");
2401 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetRecurrentToInputWeights(), supportedWeightTypes),
2402 reasonIfUnsupported,
2403 "Reference UnidirectionalSequenceLstm: RecurrentToInputWeights "
2404 "is not a supported type.");
2405 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetInputGateBias()), reasonIfUnsupported,
2406 "Reference UnidirectionalSequenceLstm: input and InputGateBias types "
2407 "are mismatched");
2408 if (descriptor.m_PeepholeEnabled)
2409 {
2410 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToInputWeights(), supportedWeightTypes),
2411 reasonIfUnsupported,
2412 "Reference UnidirectionalSequenceLstm: CellToInputWeights "
2413 "is not a supported type.");
2414 }
2415 }
2416 if (descriptor.m_PeepholeEnabled)
2417 {
2418 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToForgetWeights(), supportedWeightTypes),
2419 reasonIfUnsupported,
2420 "Reference UnidirectionalSequenceLstm: CellToForgetWeights "
2421 "is not a supported type.");
2422 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellToOutputWeights(), supportedWeightTypes),
2423 reasonIfUnsupported,
2424 "Reference UnidirectionalSequenceLstm: CellToOutputWeights "
2425 "is not a supported type.");
2426 }
2427 if (descriptor.m_ProjectionEnabled)
2428 {
2429 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetProjectionWeights(), supportedWeightTypes),
2430 reasonIfUnsupported,
2431 "Reference UnidirectionalSequenceLstm: ProjectionWeights "
2432 "is not a supported type.");
2433 if (paramsInfo.m_ProjectionBias != nullptr)
2434 {
2435 supported &= CheckSupportRule(TypesAreEqual(input, paramsInfo.GetProjectionBias()), reasonIfUnsupported,
2436 "Reference UnidirectionalSequenceLstm: input and ProjectionBias types "
2437 "are mismatched");
2438 }
2439 }
2440 if (descriptor.m_LayerNormEnabled)
2441 {
2442 if (!descriptor.m_CifgEnabled)
2443 {
2444 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetInputLayerNormWeights(), supportedWeightTypes),
2445 reasonIfUnsupported,
2446 "Reference UnidirectionalSequenceLstm: InputLayerNormWeights "
2447 "is not a supported type.");
2448 }
2449 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetForgetLayerNormWeights(), supportedWeightTypes),
2450 reasonIfUnsupported,
2451 "Reference UnidirectionalSequenceLstm: ForgetLayerNormWeights "
2452 "is not a supported type.");
2453 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetCellLayerNormWeights(), supportedWeightTypes),
2454 reasonIfUnsupported,
2455 "Reference UnidirectionalSequenceLstm: CellLayerNormWeights "
2456 "is not a supported type.");
2457 supported &= CheckSupportRule(TypeAnyOf(paramsInfo.GetOutputLayerNormWeights(), supportedWeightTypes),
2458 reasonIfUnsupported,
2459 "Reference UnidirectionalSequenceLstm: OutputLayerNormWeights "
2460 "is not a supported type.");
2461 }
2462
2463 return supported;
2464}
2465
arovir011c7c81b2018-10-08 11:34:28 +0100[diff] [blame]2466} // namespace armnn