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
|
//
// Copyright © 2022 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaTestUtils.hpp"
using namespace armnn;
using namespace tosa;
void VerifyAvgPool2DIgnoreValue(TosaSerializationBasicBlock* basicBlock,
std::vector<std::vector<int32_t>> inputShape,
std::vector<std::vector<int32_t>> outputShape,
std::vector<std::vector<int32_t>> intermediateShape,
const BaseDescriptor& descriptor,
DType dataType = DType_FP32)
{
uint32_t numInputs = static_cast<uint32_t>(inputShape.size());
uint32_t numOutputs = static_cast<uint32_t>(outputShape.size());
std::string blockStr = TosaOpToString(Op_AVG_POOL2D) + "_block_";
CHECK(basicBlock->GetName().find(blockStr) != std::string::npos);
CHECK(basicBlock->GetInputs().size() == numInputs);
CHECK(basicBlock->GetOutputs().size() == numOutputs);
CHECK(basicBlock->GetOperators().size() == 2);
CHECK(basicBlock->GetTensors().size() == 3);
//
// Verify padding operator first.
//
TosaSerializationOperator* padOp = basicBlock->GetOperators().at(0);
uint32_t padOpOutputs = 1;
CHECK(padOp->GetInputTensorNames().size() == numInputs);
CHECK(padOp->GetOutputTensorNames().size() == padOpOutputs);
for (uint32_t i = 0; i < numInputs; i++)
{
std::basic_string<char> blockInputName = basicBlock->GetInputs()[i];
std::basic_string<char> operatorInputName = padOp->GetInputTensorNames()[i];
std::string opStr = "input" + std::to_string(i) + "_";
CHECK(blockInputName == operatorInputName);
CHECK(basicBlock->GetTensorByName(blockInputName));
CHECK(blockInputName.find(opStr) != std::string::npos);
TosaSerializationTensor* tensor = basicBlock->GetTensorByName(operatorInputName);
CHECK(tensor->GetDtype() == dataType);
CHECK(tensor->GetData().size() == 0);
CHECK(tensor->GetShape() == inputShape[static_cast<unsigned long int>(i)]);
}
for (uint32_t i = 0; i < padOpOutputs; i++)
{
std::basic_string<char> operatorOutputName = padOp->GetOutputTensorNames()[i];
std::string opStr = "intermediate" + std::to_string(i) + "_";
CHECK(basicBlock->GetTensorByName(operatorOutputName));
CHECK(operatorOutputName.find(opStr) != std::string::npos);
TosaSerializationTensor* tensor = basicBlock->GetTensorByName(operatorOutputName);
CHECK(tensor->GetDtype() == dataType);
CHECK(tensor->GetData().size() == 0);
CHECK(tensor->GetShape() == intermediateShape[static_cast<unsigned long int>(i)]);
}
CHECK(padOp->GetAttributeType() == Attribute_PadAttribute);
CHECK(padOp->GetOp() == Op_PAD);
VerifyTosaAttribute(descriptor,
padOp->GetAttribute(),
inputShape[0],
outputShape[0],
LayerType::Pooling2d);
//
// Verify average pool operator second.
//
TosaSerializationOperator* poolOp = basicBlock->GetOperators().at(1);
uint32_t poolOpInputs = 1;
CHECK(poolOp->GetInputTensorNames().size() == poolOpInputs);
CHECK(poolOp->GetOutputTensorNames().size() == numOutputs);
for (uint32_t i = 0; i < poolOpInputs; i++)
{
std::basic_string<char> operatorInputName = poolOp->GetInputTensorNames()[i];
std::string opStr = "intermediate" + std::to_string(i) + "_";
CHECK(basicBlock->GetTensorByName(operatorInputName));
CHECK(operatorInputName.find(opStr) != std::string::npos);
TosaSerializationTensor* tensor = basicBlock->GetTensorByName(operatorInputName);
CHECK(tensor->GetDtype() == dataType);
CHECK(tensor->GetData().size() == 0);
CHECK(tensor->GetShape() == intermediateShape[static_cast<unsigned long int>(i)]);
}
for (uint32_t i = 0; i < numOutputs; i++)
{
std::basic_string<char> blockOutputName = basicBlock->GetOutputs()[i];
std::basic_string<char> operatorOutputName = poolOp->GetOutputTensorNames()[i];
std::string opStr = "output" + std::to_string(i) + "_";
CHECK(blockOutputName == operatorOutputName);
CHECK(basicBlock->GetTensorByName(blockOutputName));
CHECK(blockOutputName.find(opStr) != std::string::npos);
TosaSerializationTensor* tensor = basicBlock->GetTensorByName(operatorOutputName);
CHECK(tensor->GetDtype() == dataType);
CHECK(tensor->GetData().size() == 0);
CHECK(tensor->GetShape() == outputShape[static_cast<unsigned long int>(i)]);
}
CHECK(poolOp->GetAttributeType() == Attribute_PoolAttribute);
CHECK(poolOp->GetOp() == Op_AVG_POOL2D);
VerifyTosaAttribute(descriptor,
poolOp->GetAttribute(),
inputShape[0],
outputShape[0],
LayerType::Pooling2d,
1);
}
|
