Blame - src/backends/reference/RefLayerSupport.hpp - ml/armnn

2018-03-09 14:13:49 +0000

[diff] [blame]

1

//

2

David Beck

ecb56cd

2018-09-05 12:52:57 +0100

[diff] [blame]

3

// SPDX-License-Identifier: MIT

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

//

#pragma once

David Beck

2018-10-12 10:38:31 +0100

[diff] [blame^]

7

#include <armnn/ILayerSupport.hpp>

arovir01

a682410

2018-08-28 17:40:45 +0100

[diff] [blame]

8

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

namespace armnn

{

arovir01

2018-10-04 10:46:04 +0100

[diff] [blame]

12

class RefLayerSupport : public ILayerSupport

13

{

arovir01

1c7c81b

2018-10-08 11:34:28 +0100

[diff] [blame]

14

public:

15

bool IsActivationSupported(const TensorInfo& input,

16

const TensorInfo& output,

17

const ActivationDescriptor& descriptor,

18

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

19

20

bool IsAdditionSupported(const TensorInfo& input0,

21

const TensorInfo& input1,

22

const TensorInfo& output,

23

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

24

25

bool IsBatchNormalizationSupported(const TensorInfo& input,

26

const TensorInfo& output,

27

const TensorInfo& mean,

28

const TensorInfo& var,

29

const TensorInfo& beta,

30

const TensorInfo& gamma,

31

const BatchNormalizationDescriptor& descriptor,

32

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

33

34

bool IsConstantSupported(const TensorInfo& output,

35

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

36

37

bool IsConvertFp16ToFp32Supported(const TensorInfo& input,

38

const TensorInfo& output,

39

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

40

41

bool IsConvertFp32ToFp16Supported(const TensorInfo& input,

42

const TensorInfo& output,

43

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

44

45

bool IsConvolution2dSupported(const TensorInfo& input,

46

const TensorInfo& output,

47

const Convolution2dDescriptor& descriptor,

48

const TensorInfo& weights,

49

const Optional<TensorInfo>& biases,

50

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

51

52

bool IsDepthwiseConvolutionSupported(const TensorInfo& input,

53

const TensorInfo& output,

54

const DepthwiseConvolution2dDescriptor& descriptor,

55

const TensorInfo& weights,

56

const Optional<TensorInfo>& biases,

57

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

58

59

bool IsDivisionSupported(const TensorInfo& input0,

60

const TensorInfo& input1,

61

const TensorInfo& output,

62

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

63

64

bool IsFakeQuantizationSupported(const TensorInfo& input,

65

const FakeQuantizationDescriptor& descriptor,

66

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

67

68

bool IsFloorSupported(const TensorInfo& input,

69

const TensorInfo& output,

70

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

71

72

bool IsFullyConnectedSupported(const TensorInfo& input,

73

const TensorInfo& output,

74

const TensorInfo& weights,

75

const TensorInfo& biases,

76

const FullyConnectedDescriptor& descriptor,

77

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

78

79

bool IsInputSupported(const TensorInfo& input,

80

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

81

82

bool IsL2NormalizationSupported(const TensorInfo& input,

83

const TensorInfo& output,

84

const L2NormalizationDescriptor& descriptor,

85

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

86

87

bool IsLstmSupported(const TensorInfo& input,

88

const TensorInfo& outputStateIn,

89

const TensorInfo& cellStateIn,

90

const TensorInfo& scratchBuffer,

91

const TensorInfo& outputStateOut,

92

const TensorInfo& cellStateOut,

93

const TensorInfo& output,

94

const LstmDescriptor& descriptor,

95

const TensorInfo& inputToForgetWeights,

96

const TensorInfo& inputToCellWeights,

97

const TensorInfo& inputToOutputWeights,

98

const TensorInfo& recurrentToForgetWeights,

99

const TensorInfo& recurrentToCellWeights,

100

const TensorInfo& recurrentToOutputWeights,

101

const TensorInfo& forgetGateBias,

102

const TensorInfo& cellBias,

103

const TensorInfo& outputGateBias,

104

const TensorInfo* inputToInputWeights,

105

const TensorInfo* recurrentToInputWeights,

106

const TensorInfo* cellToInputWeights,

107

const TensorInfo* inputGateBias,

108

const TensorInfo* projectionWeights,

109

const TensorInfo* projectionBias,

110

const TensorInfo* cellToForgetWeights,

111

const TensorInfo* cellToOutputWeights,

112

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

113

114

bool IsMeanSupported(const TensorInfo& input,

115

const TensorInfo& output,

116

const MeanDescriptor& descriptor,

117

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

118

119

bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,

120

const OriginsDescriptor& descriptor,

121

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

122

123

bool IsMultiplicationSupported(const TensorInfo& input0,

124

const TensorInfo& input1,

125

const TensorInfo& output,

126

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

127

128

bool IsNormalizationSupported(const TensorInfo& input,

129

const TensorInfo& output,

130

const NormalizationDescriptor& descriptor,

131

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

132

133

bool IsOutputSupported(const TensorInfo& output,

134

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

135

136

bool IsPadSupported(const TensorInfo& input,

137

const TensorInfo& output,

138

const PadDescriptor& descriptor,

139

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

140

141

bool IsPermuteSupported(const TensorInfo& input,

142

const TensorInfo& output,

143

const PermuteDescriptor& descriptor,

144

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

145

146

bool IsPooling2dSupported(const TensorInfo& input,

147

const TensorInfo& output,

148

const Pooling2dDescriptor& descriptor,

149

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

150

151

bool IsReshapeSupported(const TensorInfo& input,

152

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

153

154

bool IsResizeBilinearSupported(const TensorInfo& input,

155

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

156

157

bool IsSoftmaxSupported(const TensorInfo& input,

158

const TensorInfo& output,

159

const SoftmaxDescriptor& descriptor,

160

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

161

162

bool IsSplitterSupported(const TensorInfo& input,

163

const ViewsDescriptor& descriptor,

164

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

165

166

bool IsSubtractionSupported(const TensorInfo& input0,

167

const TensorInfo& input1,

168

const TensorInfo& output,

169

Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;

arovir01

4424b0a

2018-10-04 10:46:04 +0100

[diff] [blame]

170

};

171

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

172

bool IsActivationSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

173

const TensorInfo& output,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

174

const ActivationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

175

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

176

177

bool IsAdditionSupportedRef(const TensorInfo& input0,

178

const TensorInfo& input1,

179

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

180

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

181

182

bool IsBatchNormalizationSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

183

const TensorInfo& output,

184

const TensorInfo& mean,

185

const TensorInfo& var,

186

const TensorInfo& beta,

187

const TensorInfo& gamma,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

188

const BatchNormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

189

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

190

191

bool IsConstantSupportedRef(const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

192

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

193

194

bool IsConvolution2dSupportedRef(const TensorInfo& input,

surmeh01

3537c2c

2018-05-18 16:31:43 +0100

[diff] [blame]

195

const TensorInfo& output,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

196

const Convolution2dDescriptor& descriptor,

197

const TensorInfo& weights,

David Beck

5eec11d

2018-10-04 15:43:17 +0100

[diff] [blame]

198

const Optional<TensorInfo>& biases,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

199

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

200

201

bool IsDepthwiseConvolutionSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

202

const TensorInfo& output,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

203

const DepthwiseConvolution2dDescriptor& descriptor,

204

const TensorInfo& weights,

David Beck

5eec11d

2018-10-04 15:43:17 +0100

[diff] [blame]

205

const Optional<TensorInfo>& biases,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

206

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

207

Francis Murtagh

e7a86a4

2018-08-29 12:42:10 +0100

[diff] [blame]

208

bool IsDivisionSupportedRef(const TensorInfo& input0,

209

const TensorInfo& input1,

210

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

211

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

Francis Murtagh

e7a86a4

2018-08-29 12:42:10 +0100

[diff] [blame]

212

David Beck

c2044fe

2018-09-05 15:00:38 +0100

[diff] [blame]

213

bool IsSubtractionSupportedRef(const TensorInfo& input0,

214

const TensorInfo& input1,

215

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

216

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

David Beck

c2044fe

2018-09-05 15:00:38 +0100

[diff] [blame]

217

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

218

bool IsFullyConnectedSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

219

const TensorInfo& output,

220

const TensorInfo& weights,

221

const TensorInfo& biases,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

222

const FullyConnectedDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

223

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

224

225

bool IsInputSupportedRef(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

226

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

227

228

bool IsL2NormalizationSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

229

const TensorInfo& output,

Matteo Martincigh

bcd3c85

2018-09-28 14:14:12 +0100

[diff] [blame]

230

const L2NormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

231

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

232

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

233

bool IsLstmSupportedRef(const TensorInfo& input,

234

const TensorInfo& outputStateIn,

235

const TensorInfo& cellStateIn,

236

const TensorInfo& scratchBuffer,

237

const TensorInfo& outputStateOut,

238

const TensorInfo& cellStateOut,

239

const TensorInfo& output,

240

const LstmDescriptor& descriptor,

241

const TensorInfo& inputToForgetWeights,

242

const TensorInfo& inputToCellWeights,

243

const TensorInfo& inputToOutputWeights,

244

const TensorInfo& recurrentToForgetWeights,

245

const TensorInfo& recurrentToCellWeights,

246

const TensorInfo& recurrentToOutputWeights,

247

const TensorInfo& forgetGateBias,

248

const TensorInfo& cellBias,

249

const TensorInfo& outputGateBias,

250

const TensorInfo* inputToInputWeights,

251

const TensorInfo* recurrentToInputWeights,

252

const TensorInfo* cellToInputWeights,

253

const TensorInfo* inputGateBias,

254

const TensorInfo* projectionWeights,

255

const TensorInfo* projectionBias,

256

const TensorInfo* cellToForgetWeights,

257

const TensorInfo* cellToOutputWeights,

258

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

259

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

260

bool IsMergerSupportedRef(const std::vector<const TensorInfo*> inputs,

261

const OriginsDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

262

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

263

264

bool IsMultiplicationSupportedRef(const TensorInfo& input0,

265

const TensorInfo& input1,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

266

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

267

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

268

269

bool IsNormalizationSupportedRef(const TensorInfo& input,

270

const TensorInfo& output,

271

const NormalizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

272

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

273

274

bool IsOutputSupportedRef(const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

275

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

276

277

bool IsPermuteSupportedRef(const TensorInfo& input,

278

const TensorInfo& output,

279

const PermuteDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

280

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

281

282

bool IsPooling2dSupportedRef(const TensorInfo& input,

283

const TensorInfo& output,

284

const Pooling2dDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

285

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

286

287

bool IsResizeBilinearSupportedRef(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

288

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

289

290

bool IsSoftmaxSupportedRef(const TensorInfo& input,

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

291

const TensorInfo& output,

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

292

const SoftmaxDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

293

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

294

295

bool IsSplitterSupportedRef(const TensorInfo& input,

296

const ViewsDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

297

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

298

299

bool IsFakeQuantizationSupportedRef(const TensorInfo& input,

300

const FakeQuantizationDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

301

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

302

303

bool IsReshapeSupportedRef(const TensorInfo& input,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

304

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

305

306

bool IsFloorSupportedRef(const TensorInfo& input,

307

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

308

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-03-09 14:13:49 +0000

[diff] [blame]

309

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

310

bool IsConvertFp16ToFp32SupportedRef(const TensorInfo& input,

311

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

312

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

313

314

bool IsConvertFp32ToFp16SupportedRef(const TensorInfo& input,

315

const TensorInfo& output,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

316

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

telsoa01

2018-08-31 09:22:23 +0100

[diff] [blame]

317

narpra01

32b9046

2018-09-13 11:07:48 +0100

[diff] [blame]

318

bool IsMeanSupportedRef(const TensorInfo& input,

319

const TensorInfo& output,

320

const MeanDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

321

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

narpra01

32b9046

2018-09-13 11:07:48 +0100

[diff] [blame]

322

Nina Drozd

661dfa7

2018-10-02 11:14:17 +0100

[diff] [blame]

323

bool IsPadSupportedRef(const TensorInfo& input,

324

const TensorInfo& output,

325

const PadDescriptor& descriptor,

arovir01

2018-10-08 14:48:19 +0100

[diff] [blame]

326

Optional<std::string&> reasonIfUnsupported = EmptyOptional());

Nina Drozd

661dfa7

2018-10-02 11:14:17 +0100

[diff] [blame]

327

telsoa01