1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//
// Copyright © 2020 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TestUtils.hpp"
namespace armnnDelegate
{
void CompareData(bool tensor1[], bool tensor2[], size_t tensorSize)
{
auto compareBool = [](auto a, auto b) {return (((a == 0) && (b == 0)) || ((a != 0) && (b != 0)));};
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(compareBool(tensor1[i], tensor2[i]));
}
}
void CompareData(std::vector<bool>& tensor1, bool tensor2[], size_t tensorSize)
{
auto compareBool = [](auto a, auto b) {return (((a == 0) && (b == 0)) || ((a != 0) && (b != 0)));};
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(compareBool(tensor1[i], tensor2[i]));
}
}
void CompareData(float tensor1[], float tensor2[], size_t tensorSize)
{
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(tensor1[i] == doctest::Approx( tensor2[i] ));
}
}
void CompareData(uint8_t tensor1[], uint8_t tensor2[], size_t tensorSize)
{
uint8_t tolerance = 1;
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(std::max(tensor1[i], tensor2[i]) - std::min(tensor1[i], tensor2[i]) <= tolerance);
}
}
void CompareData(int16_t tensor1[], int16_t tensor2[], size_t tensorSize)
{
int16_t tolerance = 1;
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(std::max(tensor1[i], tensor2[i]) - std::min(tensor1[i], tensor2[i]) <= tolerance);
}
}
void CompareData(int8_t tensor1[], int8_t tensor2[], size_t tensorSize)
{
int8_t tolerance = 1;
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(std::max(tensor1[i], tensor2[i]) - std::min(tensor1[i], tensor2[i]) <= tolerance);
}
}
void CompareData(Half tensor1[], Half tensor2[], size_t tensorSize)
{
for (size_t i = 0; i < tensorSize; i++)
{
CHECK(tensor1[i] == doctest::Approx( tensor2[i] ));
}
}
void CompareData(TfLiteFloat16 tensor1[], TfLiteFloat16 tensor2[], size_t tensorSize)
{
uint16_t tolerance = 1;
for (size_t i = 0; i < tensorSize; i++)
{
uint16_t tensor1Data = tensor1[i].data;
uint16_t tensor2Data = tensor2[i].data;
CHECK(std::max(tensor1Data, tensor2Data) - std::min(tensor1Data, tensor2Data) <= tolerance);
}
}
void CompareData(TfLiteFloat16 tensor1[], Half tensor2[], size_t tensorSize) {
uint16_t tolerance = 1;
for (size_t i = 0; i < tensorSize; i++)
{
uint16_t tensor1Data = tensor1[i].data;
uint16_t tensor2Data = half_float::detail::float2half<std::round_indeterminate, float>(tensor2[i]);
CHECK(std::max(tensor1Data, tensor2Data) - std::min(tensor1Data, tensor2Data) <= tolerance);
}
}
template <>
void CompareOutputData(std::unique_ptr<tflite::Interpreter>& tfLiteInterpreter,
std::unique_ptr<tflite::Interpreter>& armnnDelegateInterpreter,
std::vector<int32_t>& expectedOutputShape,
std::vector<Half>& expectedOutputValues,
unsigned int outputIndex)
{
auto tfLiteDelegateOutputId = tfLiteInterpreter->outputs()[outputIndex];
auto tfLiteDelegateOutputTensor = tfLiteInterpreter->tensor(tfLiteDelegateOutputId);
auto tfLiteDelegateOutputData = tfLiteInterpreter->typed_tensor<TfLiteFloat16>(tfLiteDelegateOutputId);
auto armnnDelegateOutputId = armnnDelegateInterpreter->outputs()[outputIndex];
auto armnnDelegateOutputTensor = armnnDelegateInterpreter->tensor(armnnDelegateOutputId);
auto armnnDelegateOutputData = armnnDelegateInterpreter->typed_tensor<TfLiteFloat16>(armnnDelegateOutputId);
CHECK(expectedOutputShape.size() == tfLiteDelegateOutputTensor->dims->size);
CHECK(expectedOutputShape.size() == armnnDelegateOutputTensor->dims->size);
for (size_t i = 0; i < expectedOutputShape.size(); i++)
{
CHECK(armnnDelegateOutputTensor->dims->data[i] == expectedOutputShape[i]);
CHECK(tfLiteDelegateOutputTensor->dims->data[i] == expectedOutputShape[i]);
CHECK(tfLiteDelegateOutputTensor->dims->data[i] == armnnDelegateOutputTensor->dims->data[i]);
}
armnnDelegate::CompareData(armnnDelegateOutputData, expectedOutputValues.data(), expectedOutputValues.size());
armnnDelegate::CompareData(tfLiteDelegateOutputData, expectedOutputValues.data(), expectedOutputValues.size());
armnnDelegate::CompareData(tfLiteDelegateOutputData, armnnDelegateOutputData, expectedOutputValues.size());
}
template <>
void FillInput<Half>(std::unique_ptr<tflite::Interpreter>& interpreter, int inputIndex, std::vector<Half>& inputValues)
{
auto tfLiteDelegateInputId = interpreter->inputs()[inputIndex];
auto tfLiteDelageInputData = interpreter->typed_tensor<TfLiteFloat16>(tfLiteDelegateInputId);
for (unsigned int i = 0; i < inputValues.size(); ++i)
{
tfLiteDelageInputData[i].data = half_float::detail::float2half<std::round_indeterminate, float>(inputValues[i]);
}
}
} // namespace armnnDelegate
|
