From 6940dd720ebb6b3d1df8ca203ab696daefe58189 Mon Sep 17 00:00:00 2001 From: Jim Flynn Date: Fri, 20 Mar 2020 12:25:56 +0000 Subject: renamed Documentation folder 20.02 and added .nojekyll file Signed-off-by: Jim Flynn --- 20.02/_layer_support_rules_8hpp_source.xhtml | 166 +++++++++++++++++++++++++++ 1 file changed, 166 insertions(+) create mode 100644 20.02/_layer_support_rules_8hpp_source.xhtml (limited to '20.02/_layer_support_rules_8hpp_source.xhtml') diff --git a/20.02/_layer_support_rules_8hpp_source.xhtml b/20.02/_layer_support_rules_8hpp_source.xhtml new file mode 100644 index 0000000000..38077e5f7c --- /dev/null +++ b/20.02/_layer_support_rules_8hpp_source.xhtml @@ -0,0 +1,166 @@ + + + + + + + + + + + + + +ArmNN: src/backends/backendsCommon/LayerSupportRules.hpp Source File + + + + + + + + + + + + + + + + +
+
+ + + + ArmNN + + + +
+
+  20.02 +
+
+
+ + + + + + + +
+
+ +
+
+
+ +
+ +
+
+ + +
+ +
+ +
+
+
LayerSupportRules.hpp
+
+
+Go to the documentation of this file.
1 //
2 // Copyright © 2017 Arm Ltd. All rights reserved.
3 // SPDX-License-Identifier: MIT
4 //
5 
6 #pragma once
7 
8 #include <boost/assert.hpp>
9 #include <algorithm>
10 
11 namespace armnn
12 {
13 
14 inline armnn::Optional<armnn::DataType> GetBiasTypeFromWeightsType(armnn::Optional<armnn::DataType> weightsType)
15 {
16  if (!weightsType)
17  {
18  return weightsType;
19  }
20 
21  switch(weightsType.value())
22  {
23  case armnn::DataType::Float16:
24  case armnn::DataType::Float32:
25  return weightsType;
26  case armnn::DataType::QAsymmU8:
27  return armnn::DataType::Signed32;
28  case armnn::DataType::QSymmS16:
29  return armnn::DataType::Signed32;
30  default:
31  BOOST_ASSERT_MSG(false, "GetBiasTypeFromWeightsType(): Unsupported data type.");
32  }
33  return armnn::EmptyOptional();
34 }
35 
36 template<typename F>
37 bool CheckSupportRule(F rule, Optional<std::string&> reasonIfUnsupported, const char* reason)
38 {
39  bool supported = rule();
40  if (!supported && reason)
41  {
42  reasonIfUnsupported.value() += std::string(reason) + "\n"; // Append the reason on a new line
43  }
44  return supported;
45 }
46 
47 struct Rule
48 {
49  bool operator()() const
50  {
51  return m_Res;
52  }
53 
54  bool m_Res = true;
55 };
56 
57 template<typename T>
58 bool AllTypesAreEqualImpl(T)
59 {
60  return true;
61 }
62 
63 template<typename T, typename... Rest>
64 bool AllTypesAreEqualImpl(T t1, T t2, Rest... rest)
65 {
66  static_assert(std::is_same<T, TensorInfo>::value, "Type T must be a TensorInfo");
67 
68  return (t1.GetDataType() == t2.GetDataType()) && AllTypesAreEqualImpl(t2, rest...);
69 }
70 
71 struct TypesAreEqual : public Rule
72 {
73  template<typename ... Ts>
74  TypesAreEqual(const Ts&... ts)
75  {
76  m_Res = AllTypesAreEqualImpl(ts...);
77  }
78 };
79 
80 struct QuantizationParametersAreEqual : public Rule
81 {
82  QuantizationParametersAreEqual(const TensorInfo& info0, const TensorInfo& info1)
83  {
84  m_Res = info0.GetQuantizationScale() == info1.GetQuantizationScale() &&
85  info0.GetQuantizationOffset() == info1.GetQuantizationOffset();
86  }
87 };
88 
89 struct TypeAnyOf : public Rule
90 {
91  template<typename Container>
92  TypeAnyOf(const TensorInfo& info, const Container& c)
93  {
94  m_Res = std::any_of(c.begin(), c.end(), [&info](DataType dt)
95  {
96  return dt == info.GetDataType();
97  });
98  }
99 };
100 
101 struct TypeIs : public Rule
102 {
103  TypeIs(const TensorInfo& info, DataType dt)
104  {
105  m_Res = dt == info.GetDataType();
106  }
107 };
108 
109 struct TypeNotPerAxisQuantized : public Rule
110 {
111  TypeNotPerAxisQuantized(const TensorInfo& info)
112  {
113  m_Res = !info.IsQuantized() || !info.HasPerAxisQuantization();
114  }
115 };
116 
117 struct BiasAndWeightsTypesMatch : public Rule
118 {
119  BiasAndWeightsTypesMatch(const TensorInfo& biases, const TensorInfo& weights)
120  {
121  m_Res = biases.GetDataType() == GetBiasTypeFromWeightsType(weights.GetDataType()).value();
122  }
123 };
124 
125 struct BiasAndWeightsTypesCompatible : public Rule
126 {
127  template<typename Container>
128  BiasAndWeightsTypesCompatible(const TensorInfo& info, const Container& c)
129  {
130  m_Res = std::any_of(c.begin(), c.end(), [&info](DataType dt)
131  {
132  return dt == GetBiasTypeFromWeightsType(info.GetDataType()).value();
133  });
134  }
135 };
136 
137 struct ShapesAreSameRank : public Rule
138 {
139  ShapesAreSameRank(const TensorInfo& info0, const TensorInfo& info1)
140  {
141  m_Res = info0.GetShape().GetNumDimensions() == info1.GetShape().GetNumDimensions();
142  }
143 };
144 
145 struct ShapesAreSameTotalSize : public Rule
146 {
147  ShapesAreSameTotalSize(const TensorInfo& info0, const TensorInfo& info1)
148  {
149  m_Res = info0.GetNumElements() == info1.GetNumElements();
150  }
151 };
152 
153 struct ShapesAreBroadcastCompatible : public Rule
154 {
155  unsigned int CalcInputSize(const TensorShape& in, const TensorShape& out, unsigned int idx)
156  {
157  unsigned int offset = out.GetNumDimensions() - in.GetNumDimensions();
158  unsigned int sizeIn = (idx < offset) ? 1 : in[idx-offset];
159  return sizeIn;
160  }
161 
162  ShapesAreBroadcastCompatible(const TensorInfo& in0, const TensorInfo& in1, const TensorInfo& out)
163  {
164  const TensorShape& shape0 = in0.GetShape();
165  const TensorShape& shape1 = in1.GetShape();
166  const TensorShape& outShape = out.GetShape();
167 
168  for (unsigned int i=0; i < outShape.GetNumDimensions() && m_Res; i++)
169  {
170  unsigned int sizeOut = outShape[i];
171  unsigned int sizeIn0 = CalcInputSize(shape0, outShape, i);
172  unsigned int sizeIn1 = CalcInputSize(shape1, outShape, i);
173 
174  m_Res &= ((sizeIn0 == sizeOut) || (sizeIn0 == 1)) &&
175  ((sizeIn1 == sizeOut) || (sizeIn1 == 1));
176  }
177  }
178 };
179 
180 struct TensorNumDimensionsAreCorrect : public Rule
181 {
182  TensorNumDimensionsAreCorrect(const TensorInfo& info, unsigned int expectedNumDimensions)
183  {
184  m_Res = info.GetNumDimensions() == expectedNumDimensions;
185  }
186 };
187 
188 } //namespace armnn
armnn::TypeNotPerAxisQuantized::TypeNotPerAxisQuantized
TypeNotPerAxisQuantized(const TensorInfo &info)
Definition: LayerSupportRules.hpp:111
+
armnn::TypeAnyOf::TypeAnyOf
TypeAnyOf(const TensorInfo &info, const Container &c)
Definition: LayerSupportRules.hpp:92
+ + + +
armnn::TensorInfo::GetShape
const TensorShape & GetShape() const
Definition: Tensor.hpp:88
+ +
armnn::TypeIs::TypeIs
TypeIs(const TensorInfo &info, DataType dt)
Definition: LayerSupportRules.hpp:103
+ + +
armnn::TensorInfo::HasPerAxisQuantization
bool HasPerAxisQuantization() const
Definition: Tensor.cpp:232
+
armnn::supported
ISubgraphViewConverter supported
Definition: ISubgraphViewConverter.hpp:31
+ + +
armnn::QuantizationParametersAreEqual::QuantizationParametersAreEqual
QuantizationParametersAreEqual(const TensorInfo &info0, const TensorInfo &info1)
Definition: LayerSupportRules.hpp:82
+ +
armnn::TypesAreEqual::TypesAreEqual
TypesAreEqual(const Ts &... ts)
Definition: LayerSupportRules.hpp:74
+ + +
armnn::Rule::operator()
bool operator()() const
Definition: LayerSupportRules.hpp:49
+
armnn
Copyright (c) 2020 ARM Limited.
Definition: 00_introduction.dox:25
+ + +
armnn::ShapesAreSameTotalSize::ShapesAreSameTotalSize
ShapesAreSameTotalSize(const TensorInfo &info0, const TensorInfo &info1)
Definition: LayerSupportRules.hpp:147
+ + +
armnn::GetBiasTypeFromWeightsType
armnn::Optional< armnn::DataType > GetBiasTypeFromWeightsType(armnn::Optional< armnn::DataType > weightsType)
Definition: LayerSupportRules.hpp:14
+ +
armnn::DataType
DataType
Definition: Types.hpp:32
+
armnn::ShapesAreBroadcastCompatible::ShapesAreBroadcastCompatible
ShapesAreBroadcastCompatible(const TensorInfo &in0, const TensorInfo &in1, const TensorInfo &out)
Definition: LayerSupportRules.hpp:162
+
armnn::TensorInfo::GetQuantizationOffset
int32_t GetQuantizationOffset() const
Definition: Tensor.cpp:264
+
armnn::BiasAndWeightsTypesCompatible::BiasAndWeightsTypesCompatible
BiasAndWeightsTypesCompatible(const TensorInfo &info, const Container &c)
Definition: LayerSupportRules.hpp:128
+
armnn::TensorInfo::GetQuantizationScale
float GetQuantizationScale() const
Definition: Tensor.cpp:247
+
armnn::TensorInfo::GetDataType
DataType GetDataType() const
Definition: Tensor.hpp:95
+ + +
armnn::BiasAndWeightsTypesMatch::BiasAndWeightsTypesMatch
BiasAndWeightsTypesMatch(const TensorInfo &biases, const TensorInfo &weights)
Definition: LayerSupportRules.hpp:119
+
armnn::ShapesAreSameRank::ShapesAreSameRank
ShapesAreSameRank(const TensorInfo &info0, const TensorInfo &info1)
Definition: LayerSupportRules.hpp:139
+ +
armnn::AllTypesAreEqualImpl
bool AllTypesAreEqualImpl(T)
Definition: LayerSupportRules.hpp:58
+
armnn::ShapesAreBroadcastCompatible::CalcInputSize
unsigned int CalcInputSize(const TensorShape &in, const TensorShape &out, unsigned int idx)
Definition: LayerSupportRules.hpp:155
+
armnn::EmptyOptional
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
Definition: Optional.hpp:32
+ + +
armnn::TensorShape::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:43
+
armnn::TensorNumDimensionsAreCorrect::TensorNumDimensionsAreCorrect
TensorNumDimensionsAreCorrect(const TensorInfo &info, unsigned int expectedNumDimensions)
Definition: LayerSupportRules.hpp:182
+ + +
armnn::TensorInfo::GetNumDimensions
unsigned int GetNumDimensions() const
Definition: Tensor.hpp:92
+
armnn::TensorInfo::IsQuantized
bool IsQuantized() const
Definition: Tensor.cpp:290
+ +
armnn::CheckSupportRule
bool CheckSupportRule(F rule, Optional< std::string &> reasonIfUnsupported, const char *reason)
Definition: LayerSupportRules.hpp:37
+
armnn::TensorInfo::GetNumElements
unsigned int GetNumElements() const
Definition: Tensor.hpp:93
+
+
+ + + + -- cgit v1.2.1