Blame - tests/validation/NEON/DepthConvertLayer.cpp - ml/ComputeLibrary

2019-05-14 17:10:40 +0100

[diff] [blame]

49

const auto DepthConvertLayerQASYMM8toS32Dataset = combine(framework::dataset::make("DataType", DataType::QASYMM8), framework::dataset::make("DataType", DataType::S32));

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

50

const auto DepthConvertLayerU8toU16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::U16));

51

const auto DepthConvertLayerU8toS16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S16));

52

const auto DepthConvertLayerU8toS32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::S32));

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

53

const auto DepthConvertLayerU8toF16Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F16));

54

const auto DepthConvertLayerU8toF32Dataset = combine(framework::dataset::make("DataType", DataType::U8), framework::dataset::make("DataType", DataType::F32));

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

55

const auto DepthConvertLayerU16toU8Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U8));

56

const auto DepthConvertLayerU16toU32Dataset = combine(framework::dataset::make("DataType", DataType::U16), framework::dataset::make("DataType", DataType::U32));

57

const auto DepthConvertLayerS16toU8Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::U8));

58

const auto DepthConvertLayerS16toS32Dataset = combine(framework::dataset::make("DataType", DataType::S16), framework::dataset::make("DataType", DataType::S32));

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

59

const auto DepthConvertLayerF16toU8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::U8));

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

60

const auto DepthConvertLayerF16toF32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::F32));

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

61

const auto DepthConvertLayerF16toS32Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::S32));

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

62

const auto DepthConvertLayerF32toF16Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::F16));

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

63

const auto DepthConvertLayerF32toS32Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::S32));

64

const auto DepthConvertLayerF32toU8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::U8));

65

66

const auto DepthConvertLayerS32toF32Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F32));

67

const auto DepthConvertLayerS32toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::QASYMM8));

68

const auto DepthConvertLayerS32toF16Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::F16));

69

const auto DepthConvertLayerS32toU8Dataset = combine(framework::dataset::make("DataType", DataType::S32), framework::dataset::make("DataType", DataType::U8));

70

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

71

const auto DepthConvertLayerF16toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::F16), framework::dataset::make("DataType", DataType::QASYMM8));

72

const auto DepthConvertLayerF32toQASYMM8Dataset = combine(framework::dataset::make("DataType", DataType::F32), framework::dataset::make("DataType", DataType::QASYMM8));

73

const auto DepthConvertLayerShiftDatasetNightly = framework::dataset::make("Shift", 0, 7);

74

const auto DepthConvertLayerShiftDatasetPrecommit = framework::dataset::make("Shift", { 0, 3, 6 });

75

const auto DepthConvertLayerZeroShiftDataset = framework::dataset::make("Shift", 0);

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

76

77

constexpr AbsoluteTolerance<uint8_t> tolerance_qasymm8(1);

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

78

constexpr AbsoluteTolerance<int32_t> tolerance_one_int32(1);

Michalis Spyrou

775c7f5

2019-06-05 11:45:16 +0100

[diff] [blame]

79

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

80

constexpr AbsoluteTolerance<uint8_t> tolerance_one_uint8(1);

Michalis Spyrou

775c7f5

2019-06-05 11:45:16 +0100

[diff] [blame]

81

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

} // namespace

TEST_SUITE(NEON)

TEST_SUITE(DepthConvertLayer)

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

// *INDENT-OFF*

// clang-format off

DATA_TEST_CASE(Validate, framework::DatasetMode::ALL, zip(zip(zip(zip(

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

90

framework::dataset::make("InputInfo", { TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U16), // Invalid data type combination

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

91

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::S16), // Invalid data type combination

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

92

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8), // Mismatching shapes

93

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), // Invalid shift

94

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8), // Valid

95

}),

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

96

framework::dataset::make("OutputInfo",{ TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

97

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::F32),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

98

TensorInfo(TensorShape(32U, 13U, 2U), 1, DataType::U8),

99

TensorInfo(TensorShape(27U, 13U, 2U), 1, DataType::U8),

100

})),

101

framework::dataset::make("Policy",{ ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

ConvertPolicy::WRAP,

})),

framework::dataset::make("Shift",{ 1, 1, 1, 1, 1, 1, 8, 1,

110

})),

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

111

framework::dataset::make("Expected", { false, false, false, false, true})),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

112

input_info, output_info, policy, shift, expected)

113

{

114

ARM_COMPUTE_EXPECT(bool(NEDepthConvertLayer::validate(&input_info.clone()->set_is_resizable(false), &output_info.clone()->set_is_resizable(false), policy, shift)) == expected, framework::LogLevel::ERRORS);

}

// clang-format on

// *INDENT-ON*

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

119

template <typename T>

120

using NEDepthConvertLayerToU16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint16_t>;

121

template <typename T>

122

using NEDepthConvertLayerToS16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, int16_t>;

123

template <typename T>

124

using NEDepthConvertLayerToS32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, int32_t>;

125

template <typename T>

126

using NEDepthConvertLayerToU8Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint8_t>;

127

template <typename T>

128

using NEDepthConvertLayerToU32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint32_t>;

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

129

template <typename T>

130

using NEDepthConvertLayerToF16Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, half>;

131

template <typename T>

132

using NEDepthConvertLayerToF32Fixture = DepthConvertLayerValidationFixture<Tensor, Accessor, NEDepthConvertLayer, T, float>;

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

133

template <typename T>

134

using NEDepthConvertLayerToQASYMM8Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, uint8_t>;

135

template <typename T>

136

using NEDepthConvertLayerQuantizedToF16Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, half>;

137

template <typename T>

138

using NEDepthConvertLayerQuantizedToF32Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, float>;

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

139

template <typename T>

140

using NEDepthConvertLayerQuantizedToS32Fixture = DepthConvertLayerValidationQuantizedFixture<Tensor, Accessor, NEDepthConvertLayer, T, int32_t>;

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

141

142

TEST_SUITE(QASYMM8_to_F32)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

143

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

144

DepthConvertLayerZeroShiftDataset),

145

shape, policy, shift)

146

{

147

// Create tensors

148

Tensor src = create_tensor<Tensor>(shape, DataType::QASYMM8, 1);

149

Tensor dst = create_tensor<Tensor>(shape, DataType::F32, 1);

150

151

// Create and Configure function

152

NEDepthConvertLayer depth_convert;

153

depth_convert.configure(&src, &dst, policy, shift);

154

155

// Validate valid region

156

const ValidRegion valid_region = shape_to_valid_region(shape);

157

validate(dst.info()->valid_region(), valid_region);

158

159

// Validate padding

160

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

161

validate(src.info()->padding(), padding);

162

validate(dst.info()->padding(), padding);

163

}

164

165

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToF32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

166

DepthConvertLayerQASYMM8toF32Dataset),

167

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

168

DepthConvertLayerZeroShiftDataset),

169

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

170

{

171

// Validate output

172

validate(Accessor(_target), _reference);

173

}

174

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToF32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

175

DepthConvertLayerQASYMM8toF32Dataset),

176

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

177

DepthConvertLayerZeroShiftDataset),

178

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

179

{

180

// Validate output

181

validate(Accessor(_target), _reference);

182

}

183

TEST_SUITE_END() // QASYMM8_to_F32

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

184

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

185

TEST_SUITE(QASYMM8_to_S32)

186

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

187

DepthConvertLayerZeroShiftDataset),

188

shape, policy, shift)

189

{

190

// Create tensors

191

Tensor src = create_tensor<Tensor>(shape, DataType::QASYMM8, 1);

192

Tensor dst = create_tensor<Tensor>(shape, DataType::S32, 1);

193

194

// Create and Configure function

195

NEDepthConvertLayer depth_convert;

196

depth_convert.configure(&src, &dst, policy, shift);

197

198

// Validate valid region

199

const ValidRegion valid_region = shape_to_valid_region(shape);

200

validate(dst.info()->valid_region(), valid_region);

201

202

// Validate padding

203

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

204

validate(src.info()->padding(), padding);

205

validate(dst.info()->padding(), padding);

206

}

207

208

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToS32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

209

DepthConvertLayerQASYMM8toS32Dataset),

210

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

211

DepthConvertLayerZeroShiftDataset),

212

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

213

{

214

// Validate output

215

validate(Accessor(_target), _reference);

216

}

217

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToS32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

218

DepthConvertLayerQASYMM8toS32Dataset),

219

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

220

DepthConvertLayerZeroShiftDataset),

221

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

222

{

223

// Validate output

224

validate(Accessor(_target), _reference);

225

}

226

TEST_SUITE_END() // QASYMM8_to_S32

227

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

228

TEST_SUITE(U8_to_U16)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

229

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

230

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

231

shape, policy, shift)

232

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

233

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

234

Tensor src = create_tensor<Tensor>(shape, DataType::U8, 1);

235

Tensor dst = create_tensor<Tensor>(shape, DataType::U16, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

236

237

// Create and Configure function

238

NEDepthConvertLayer depth_convert;

239

depth_convert.configure(&src, &dst, policy, shift);

240

241

// Validate valid region

242

const ValidRegion valid_region = shape_to_valid_region(shape);

243

validate(dst.info()->valid_region(), valid_region);

244

245

// Validate padding

246

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

247

validate(src.info()->padding(), padding);

248

validate(dst.info()->padding(), padding);

249

}

250

251

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toU16Dataset),

252

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

253

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

254

{

255

// Validate output

256

validate(Accessor(_target), _reference);

257

}

258

259

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toU16Dataset),

260

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

261

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

262

{

263

// Validate output

264

validate(Accessor(_target), _reference);

265

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

266

TEST_SUITE_END() // U8_to_U16

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

267

268

TEST_SUITE(U8_to_S16)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

269

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

270

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

271

shape, policy, shift)

272

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

273

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

274

Tensor src = create_tensor<Tensor>(shape, DataType::U8, 1);

275

Tensor dst = create_tensor<Tensor>(shape, DataType::S16, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

276

277

// Create and Configure function

278

NEDepthConvertLayer depth_convert;

279

depth_convert.configure(&src, &dst, policy, shift);

280

281

// Validate valid region

282

const ValidRegion valid_region = shape_to_valid_region(shape);

283

validate(dst.info()->valid_region(), valid_region);

284

285

// Validate padding

286

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

287

validate(src.info()->padding(), padding);

288

validate(dst.info()->padding(), padding);

289

}

290

291

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS16Dataset),

292

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

293

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

294

{

295

// Validate output

296

validate(Accessor(_target), _reference);

297

}

298

299

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS16Dataset),

300

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

301

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

302

{

303

// Validate output

304

validate(Accessor(_target), _reference);

305

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

306

TEST_SUITE_END() // U8_to_S16

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

307

TEST_SUITE(U8_to_S32)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

308

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

309

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

310

shape, policy, shift)

311

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

312

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

313

Tensor src = create_tensor<Tensor>(shape, DataType::U8, 1);

314

Tensor dst = create_tensor<Tensor>(shape, DataType::S32, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

315

316

// Create and Configure function

317

NEDepthConvertLayer depth_convert;

318

depth_convert.configure(&src, &dst, policy, shift);

319

320

// Validate valid region

321

const ValidRegion valid_region = shape_to_valid_region(shape);

322

validate(dst.info()->valid_region(), valid_region);

323

324

// Validate padding

325

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

326

validate(src.info()->padding(), padding);

327

validate(dst.info()->padding(), padding);

328

}

329

330

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toS32Dataset),

331

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

332

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

333

{

334

// Validate output

335

validate(Accessor(_target), _reference);

336

}

337

338

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toS32Dataset),

339

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

340

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

341

{

342

// Validate output

343

validate(Accessor(_target), _reference);

344

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

345

TEST_SUITE_END() // U8_to_S32

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

346

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

347

348

TEST_SUITE(U8_to_F32)

349

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

350

DepthConvertLayerShiftDatasetNightly),

351

shape, policy, shift)

352

{

353

// Create tensors

354

Tensor src = create_tensor<Tensor>(shape, DataType::U8, 1);

355

Tensor dst = create_tensor<Tensor>(shape, DataType::F32, 1);

356

357

// Create and Configure function

358

NEDepthConvertLayer depth_convert;

359

depth_convert.configure(&src, &dst, policy, shift);

360

361

// Validate valid region

362

const ValidRegion valid_region = shape_to_valid_region(shape);

363

validate(dst.info()->valid_region(), valid_region);

364

365

// Validate padding

366

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

367

validate(src.info()->padding(), padding);

368

validate(dst.info()->padding(), padding);

369

}

370

371

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toF32Dataset),

372

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

373

DepthConvertLayerShiftDatasetPrecommit))

374

{

375

// Validate output

376

validate(Accessor(_target), _reference);

377

}

378

379

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF32Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toF32Dataset),

380

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

381

DepthConvertLayerShiftDatasetNightly))

382

{

383

// Validate output

384

validate(Accessor(_target), _reference);

385

}

386

TEST_SUITE_END() // U8_to_F32

387

388

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

389

TEST_SUITE(U8_to_F16)

390

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

391

DepthConvertLayerShiftDatasetNightly),

392

shape, policy, shift)

393

{

394

// Create tensors

395

Tensor src = create_tensor<Tensor>(shape, DataType::U8, 1);

396

Tensor dst = create_tensor<Tensor>(shape, DataType::F16, 1);

397

398

// Create and Configure function

399

NEDepthConvertLayer depth_convert;

400

depth_convert.configure(&src, &dst, policy, shift);

401

402

// Validate valid region

403

const ValidRegion valid_region = shape_to_valid_region(shape);

404

validate(dst.info()->valid_region(), valid_region);

405

406

// Validate padding

407

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

408

validate(src.info()->padding(), padding);

409

validate(dst.info()->padding(), padding);

410

}

411

412

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU8toF16Dataset),

413

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

414

DepthConvertLayerShiftDatasetPrecommit))

415

{

416

// Validate output

417

validate(Accessor(_target), _reference);

418

}

419

420

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU8toF16Dataset),

421

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

422

DepthConvertLayerShiftDatasetNightly))

423

{

424

// Validate output

425

validate(Accessor(_target), _reference);

426

}

427

TEST_SUITE_END() // U8_to_F36

428

#endif // __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

429

430

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

431

TEST_SUITE(U16_to_U8)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

432

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

433

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

434

shape, policy, shift)

435

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

436

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

437

Tensor src = create_tensor<Tensor>(shape, DataType::U16, 1);

438

Tensor dst = create_tensor<Tensor>(shape, DataType::U8, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

439

440

// Create and Configure function

441

NEDepthConvertLayer depth_convert;

442

depth_convert.configure(&src, &dst, policy, shift);

443

444

// Validate valid region

445

const ValidRegion valid_region = shape_to_valid_region(shape);

446

validate(dst.info()->valid_region(), valid_region);

447

448

// Validate padding

449

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

450

validate(src.info()->padding(), padding);

451

validate(dst.info()->padding(), padding);

452

}

453

454

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<uint16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU8Dataset),

455

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

456

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

457

{

458

// Validate output

459

validate(Accessor(_target), _reference);

460

}

461

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<uint16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU8Dataset),

462

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

463

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

464

{

465

// Validate output

466

validate(Accessor(_target), _reference);

467

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

468

TEST_SUITE_END() // U16_to_U8

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

469

470

TEST_SUITE(U16_to_U32)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

471

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

472

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

473

shape, policy, shift)

474

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

475

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

476

Tensor src = create_tensor<Tensor>(shape, DataType::U16, 1);

477

Tensor dst = create_tensor<Tensor>(shape, DataType::U32, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

478

479

// Create and Configure function

480

NEDepthConvertLayer depth_convert;

481

depth_convert.configure(&src, &dst, policy, shift);

482

483

// Validate valid region

484

const ValidRegion valid_region = shape_to_valid_region(shape);

485

validate(dst.info()->valid_region(), valid_region);

486

487

// Validate padding

488

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

489

validate(src.info()->padding(), padding);

490

validate(dst.info()->padding(), padding);

491

}

492

493

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU32Fixture<uint16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerU16toU32Dataset),

494

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

495

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

496

{

497

// Validate output

498

validate(Accessor(_target), _reference);

499

}

500

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU32Fixture<uint16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerU16toU32Dataset),

501

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

502

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

503

{

504

// Validate output

505

validate(Accessor(_target), _reference);

506

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

507

TEST_SUITE_END() // U16_to_U32

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

508

509

TEST_SUITE(S16_to_U8)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

510

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

511

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

512

shape, policy, shift)

513

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

514

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

515

Tensor src = create_tensor<Tensor>(shape, DataType::S16, 1);

516

Tensor dst = create_tensor<Tensor>(shape, DataType::U8, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

517

518

// Create and Configure function

519

NEDepthConvertLayer depth_convert;

520

depth_convert.configure(&src, &dst, policy, shift);

521

522

// Validate valid region

523

const ValidRegion valid_region = shape_to_valid_region(shape);

524

validate(dst.info()->valid_region(), valid_region);

525

526

// Validate padding

527

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

528

validate(src.info()->padding(), padding);

529

validate(dst.info()->padding(), padding);

530

}

531

532

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toU8Dataset),

533

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

534

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

535

{

536

// Validate output

537

validate(Accessor(_target), _reference);

538

}

539

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toU8Dataset),

540

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

541

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

542

{

543

// Validate output

544

validate(Accessor(_target), _reference);

545

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

546

TEST_SUITE_END() // S16_to_U8

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

547

548

TEST_SUITE(S16_to_S32)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

549

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

550

DepthConvertLayerShiftDatasetNightly),

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

551

shape, policy, shift)

552

{

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

553

// Create tensors

Vidhya Sudhan Loganathan

2018-07-02 09:13:49 +0100

[diff] [blame]

554

Tensor src = create_tensor<Tensor>(shape, DataType::S16, 1);

555

Tensor dst = create_tensor<Tensor>(shape, DataType::S32, 1);

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

556

557

// Create and Configure function

558

NEDepthConvertLayer depth_convert;

559

depth_convert.configure(&src, &dst, policy, shift);

560

561

// Validate valid region

562

const ValidRegion valid_region = shape_to_valid_region(shape);

563

validate(dst.info()->valid_region(), valid_region);

564

565

// Validate padding

566

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

567

validate(src.info()->padding(), padding);

568

validate(dst.info()->padding(), padding);

569

}

570

571

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<int16_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS16toS32Dataset),

572

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

573

DepthConvertLayerShiftDatasetPrecommit))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

574

{

575

// Validate output

576

validate(Accessor(_target), _reference);

577

}

578

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<int16_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS16toS32Dataset),

579

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2019-01-09 14:21:03 +0000

[diff] [blame]

580

DepthConvertLayerShiftDatasetNightly))

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

581

{

582

// Validate output

583

validate(Accessor(_target), _reference);

584

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

585

TEST_SUITE_END() // S16_to_S32

Giorgio Arena

2017-11-23 11:45:24 +0000

[diff] [blame]

586

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

587

#ifdef __ARM_FEATURE_FP16_VECTOR_ARITHMETIC

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

588

TEST_SUITE(F16_to_QASYMM8)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

589

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

590

DepthConvertLayerZeroShiftDataset),

591

shape, policy, shift)

592

{

593

// Create tensors

594

Tensor src = create_tensor<Tensor>(shape, DataType::F16, 1);

595

Tensor dst = create_tensor<Tensor>(shape, DataType::QASYMM8, 1);

596

597

// Create and Configure function

598

NEDepthConvertLayer depth_convert;

599

depth_convert.configure(&src, &dst, policy, shift);

600

601

// Validate valid region

602

const ValidRegion valid_region = shape_to_valid_region(shape);

603

validate(dst.info()->valid_region(), valid_region);

604

605

// Validate padding

606

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

607

validate(src.info()->padding(), padding);

608

validate(dst.info()->padding(), padding);

609

}

610

611

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToQASYMM8Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

612

DepthConvertLayerF16toQASYMM8Dataset),

613

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

614

DepthConvertLayerZeroShiftDataset),

615

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

616

{

617

// Validate output

618

validate(Accessor(_target), _reference, tolerance_qasymm8);

619

}

620

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToQASYMM8Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

621

DepthConvertLayerF16toQASYMM8Dataset),

622

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

623

DepthConvertLayerZeroShiftDataset),

624

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

625

{

626

// Validate output

627

validate(Accessor(_target), _reference, tolerance_qasymm8);

628

}

629

TEST_SUITE_END() // F16_to_QASYMM8

630

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

631

632

TEST_SUITE(F16_to_U8)

633

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

634

DepthConvertLayerZeroShiftDataset),

635

shape, policy, shift)

636

{

637

// Create tensors

638

Tensor src = create_tensor<Tensor>(shape, DataType::F16, 1);

639

Tensor dst = create_tensor<Tensor>(shape, DataType::U8, 1);

640

641

// Create and Configure function

642

NEDepthConvertLayer depth_convert;

643

depth_convert.configure(&src, &dst, policy, shift);

644

645

// Validate valid region

646

const ValidRegion valid_region = shape_to_valid_region(shape);

647

validate(dst.info()->valid_region(), valid_region);

648

649

// Validate padding

650

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

651

validate(src.info()->padding(), padding);

652

validate(dst.info()->padding(), padding);

653

}

654

655

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toU8Dataset),

656

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

657

DepthConvertLayerZeroShiftDataset))

658

{

659

// Validate output

660

validate(Accessor(_target), _reference, tolerance_one_uint8);

661

}

662

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toU8Dataset),

663

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

664

DepthConvertLayerZeroShiftDataset))

665

{

666

// Validate output

667

validate(Accessor(_target), _reference, tolerance_one_uint8);

668

}

669

TEST_SUITE_END() // F16_to_U8

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

673

TEST_SUITE(F16_to_F32)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

674

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

675

DepthConvertLayerZeroShiftDataset),

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

676

shape, policy, shift)

677

{

678

// Create tensors

679

Tensor src = create_tensor<Tensor>(shape, DataType::F16, 1);

680

Tensor dst = create_tensor<Tensor>(shape, DataType::F32, 1);

681

682

// Create and Configure function

683

NEDepthConvertLayer depth_convert;

684

depth_convert.configure(&src, &dst, policy, shift);

685

686

// Validate valid region

687

const ValidRegion valid_region = shape_to_valid_region(shape);

688

validate(dst.info()->valid_region(), valid_region);

689

690

// Validate padding

691

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

692

validate(src.info()->padding(), padding);

693

validate(dst.info()->padding(), padding);

694

}

695

696

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF32Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toF32Dataset),

697

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

698

DepthConvertLayerZeroShiftDataset))

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

699

{

700

// Validate output

701

validate(Accessor(_target), _reference);

702

}

703

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF32Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toF32Dataset),

704

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

705

DepthConvertLayerZeroShiftDataset))

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

706

{

707

// Validate output

708

validate(Accessor(_target), _reference);

709

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

710

TEST_SUITE_END() // F16_to_F32

711

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

712

TEST_SUITE(F16_to_S32)

713

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

714

DepthConvertLayerZeroShiftDataset),

715

shape, policy, shift)

716

{

717

// Create tensors

718

Tensor src = create_tensor<Tensor>(shape, DataType::F16, 1);

719

Tensor dst = create_tensor<Tensor>(shape, DataType::S32, 1);

720

721

// Create and Configure function

722

NEDepthConvertLayer depth_convert;

723

depth_convert.configure(&src, &dst, policy, shift);

724

725

// Validate valid region

726

const ValidRegion valid_region = shape_to_valid_region(shape);

727

validate(dst.info()->valid_region(), valid_region);

728

729

// Validate padding

730

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

731

validate(src.info()->padding(), padding);

732

validate(dst.info()->padding(), padding);

733

}

734

735

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<half>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF16toS32Dataset),

736

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

737

DepthConvertLayerZeroShiftDataset))

738

{

739

// Validate output

740

validate(Accessor(_target), _reference, tolerance_one_int32);

741

}

742

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<half>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF16toS32Dataset),

743

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

744

DepthConvertLayerZeroShiftDataset))

745

{

746

// Validate output

747

validate(Accessor(_target), _reference, tolerance_one_int32);

748

}

749

750

TEST_SUITE_END() // F16_to_S32

751

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

752

TEST_SUITE(QASYMM8_to_F16)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

753

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

754

DepthConvertLayerZeroShiftDataset),

755

shape, policy, shift)

756

{

757

// Create tensors

758

Tensor src = create_tensor<Tensor>(shape, DataType::QASYMM8, 1);

759

Tensor dst = create_tensor<Tensor>(shape, DataType::F16, 1);

760

761

// Create and Configure function

762

NEDepthConvertLayer depth_convert;

763

depth_convert.configure(&src, &dst, policy, shift);

764

765

// Validate valid region

766

const ValidRegion valid_region = shape_to_valid_region(shape);

767

validate(dst.info()->valid_region(), valid_region);

768

769

// Validate padding

770

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

771

validate(src.info()->padding(), padding);

772

validate(dst.info()->padding(), padding);

773

}

774

775

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerQuantizedToF16Fixture<uint8_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

776

DepthConvertLayerQASYMM8toF16Dataset),

777

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

778

DepthConvertLayerZeroShiftDataset),

779

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

780

{

781

// Validate output

782

validate(Accessor(_target), _reference);

783

}

784

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerQuantizedToF16Fixture<uint8_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

785

DepthConvertLayerQASYMM8toF16Dataset),

786

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

787

DepthConvertLayerZeroShiftDataset),

788

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

789

{

790

// Validate output

791

validate(Accessor(_target), _reference);

792

}

793

TEST_SUITE_END() // QASYMM8_to_F16

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

794

795

TEST_SUITE(F32_to_F16)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

796

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

797

DepthConvertLayerZeroShiftDataset),

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

798

shape, policy, shift)

799

{

800

// Create tensors

801

Tensor src = create_tensor<Tensor>(shape, DataType::F32, 1);

802

Tensor dst = create_tensor<Tensor>(shape, DataType::F16, 1);

803

804

// Create and Configure function

805

NEDepthConvertLayer depth_convert;

806

depth_convert.configure(&src, &dst, policy, shift);

807

808

// Validate valid region

809

const ValidRegion valid_region = shape_to_valid_region(shape);

810

validate(dst.info()->valid_region(), valid_region);

811

812

// Validate padding

813

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

814

validate(src.info()->padding(), padding);

815

validate(dst.info()->padding(), padding);

816

}

817

818

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toF16Dataset),

819

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

820

DepthConvertLayerZeroShiftDataset))

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

821

{

822

// Validate output

823

validate(Accessor(_target), _reference);

824

}

825

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toF16Dataset),

826

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Georgios Pinitas

2018-12-04 13:46:48 +0000

[diff] [blame]

827

DepthConvertLayerZeroShiftDataset))

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

828

{

829

// Validate output

830

validate(Accessor(_target), _reference);

831

}

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

832

TEST_SUITE_END() // F32_to_F16

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

833

834

TEST_SUITE(S32_to_F16)

835

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

836

DepthConvertLayerZeroShiftDataset),

837

shape, policy, shift)

838

{

839

// Create tensors

840

Tensor src = create_tensor<Tensor>(shape, DataType::S32, 1);

841

Tensor dst = create_tensor<Tensor>(shape, DataType::F16, 1);

842

843

// Create and Configure function

844

NEDepthConvertLayer depth_convert;

845

depth_convert.configure(&src, &dst, policy, shift);

846

847

// Validate valid region

848

const ValidRegion valid_region = shape_to_valid_region(shape);

849

validate(dst.info()->valid_region(), valid_region);

850

851

// Validate padding

852

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

853

validate(src.info()->padding(), padding);

854

validate(dst.info()->padding(), padding);

855

}

856

857

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToF16Fixture<int32_t>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerS32toF16Dataset),

858

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

859

DepthConvertLayerZeroShiftDataset))

860

{

861

// Validate output

862

validate(Accessor(_target), _reference);

863

}

864

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToF16Fixture<int32_t>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerS32toF16Dataset),

865

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

866

DepthConvertLayerZeroShiftDataset))

867

{

868

// Validate output

869

validate(Accessor(_target), _reference);

870

}

871

TEST_SUITE_END() // S32_to_F16

872

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

873

#endif /* __ARM_FEATURE_FP16_VECTOR_ARITHMETIC */

Michele Di Giorgio

2018-08-24 18:28:48 +0100

[diff] [blame]

874

Usama Arif

2019-05-14 17:10:40 +0100

[diff] [blame]

875

TEST_SUITE(F32_to_S32)

876

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

877

DepthConvertLayerZeroShiftDataset),

878

shape, policy, shift)

879

{

880

// Create tensors

881

Tensor src = create_tensor<Tensor>(shape, DataType::F32, 1);

882

Tensor dst = create_tensor<Tensor>(shape, DataType::S32, 1);

883

884

// Create and Configure function

885

NEDepthConvertLayer depth_convert;

886

depth_convert.configure(&src, &dst, policy, shift);

887

888

// Validate valid region

889

const ValidRegion valid_region = shape_to_valid_region(shape);

890

validate(dst.info()->valid_region(), valid_region);

891

892

// Validate padding

893

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

894

validate(src.info()->padding(), padding);

895

validate(dst.info()->padding(), padding);

896

}

897

898

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToS32Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toS32Dataset),

899

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

900

DepthConvertLayerZeroShiftDataset))

901

{

902

// Validate output

903

validate(Accessor(_target), _reference, tolerance_one_int32);

904

}

905

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToS32Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toS32Dataset),

906

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

907

DepthConvertLayerZeroShiftDataset))

908

{

909

// Validate output

910

validate(Accessor(_target), _reference, tolerance_one_int32);

911

}

912

TEST_SUITE_END() // F32_to_S32

913

914

TEST_SUITE(F32_to_U8)

915

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

916

DepthConvertLayerZeroShiftDataset),

917

shape, policy, shift)

918

{

919

// Create tensors

920

Tensor src = create_tensor<Tensor>(shape, DataType::F32, 1);

921

Tensor dst = create_tensor<Tensor>(shape, DataType::U8, 1);

922

923

// Create and Configure function

924

NEDepthConvertLayer depth_convert;

925

depth_convert.configure(&src, &dst, policy, shift);

926

927

// Validate valid region

928

const ValidRegion valid_region = shape_to_valid_region(shape);

929

validate(dst.info()->valid_region(), valid_region);

930

931

// Validate padding

932

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

933

validate(src.info()->padding(), padding);

934

validate(dst.info()->padding(), padding);

935

}

936

937

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToU8Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(datasets::SmallShapes(), DepthConvertLayerF32toU8Dataset),

938

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

939

DepthConvertLayerZeroShiftDataset))

940

{

941

// Validate output

942

validate(Accessor(_target), _reference, tolerance_one_int32);

943

}

944

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToU8Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(datasets::LargeShapes(), DepthConvertLayerF32toU8Dataset),

945

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

946

DepthConvertLayerZeroShiftDataset))

947

{

948

// Validate output

949

validate(Accessor(_target), _reference, tolerance_one_int32);

950

}

951

TEST_SUITE_END() // F32_to_U8

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

955

TEST_SUITE(F32_to_QASYMM8)

Michalis Spyrou

2019-01-16 14:48:48 +0000

[diff] [blame]

956

DATA_TEST_CASE(Configuration, framework::DatasetMode::ALL, combine(combine(datasets::SmallShapes(), framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE, ConvertPolicy::WRAP })),

Michalis Spyrou

2018-12-13 18:31:18 +0000

[diff] [blame]

957

DepthConvertLayerZeroShiftDataset),

958

shape, policy, shift)

959

{

960

// Create tensors

961

Tensor src = create_tensor<Tensor>(shape, DataType::F32, 1);

962

Tensor dst = create_tensor<Tensor>(shape, DataType::QASYMM8, 1);

963

964

// Create and Configure function

965

NEDepthConvertLayer depth_convert;

966

depth_convert.configure(&src, &dst, policy, shift);

967

968

// Validate valid region

969

const ValidRegion valid_region = shape_to_valid_region(shape);

970

validate(dst.info()->valid_region(), valid_region);

971

972

// Validate padding

973

const PaddingSize padding = PaddingCalculator(shape.x(), 16).required_padding();

974

validate(src.info()->padding(), padding);

975

validate(dst.info()->padding(), padding);

976

}

977

978

FIXTURE_DATA_TEST_CASE(RunSmall, NEDepthConvertLayerToQASYMM8Fixture<float>, framework::DatasetMode::PRECOMMIT, combine(combine(combine(combine(datasets::SmallShapes(),

979

DepthConvertLayerF32toQASYMM8Dataset),

980

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

981

DepthConvertLayerZeroShiftDataset),

982

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

983

{

984

// Validate output

985

validate(Accessor(_target), _reference, tolerance_qasymm8);

986

}

987

FIXTURE_DATA_TEST_CASE(RunLarge, NEDepthConvertLayerToQASYMM8Fixture<float>, framework::DatasetMode::NIGHTLY, combine(combine(combine(combine(datasets::LargeShapes(),

988

DepthConvertLayerF32toQASYMM8Dataset),

989

framework::dataset::make("ConvertPolicy", { ConvertPolicy::SATURATE })),

990

DepthConvertLayerZeroShiftDataset),

991

framework::dataset::make("QuantizationInfo", { QuantizationInfo(0.5f, 10) })))

992

{

993

// Validate output

994

validate(Accessor(_target), _reference, tolerance_qasymm8);

995

}

996

TEST_SUITE_END() // F32_to_QASYMM8

Usama Arif