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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
//
// Copyright © 2022-2024 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "TosaMappings.hpp"
using namespace armnn;
using namespace tosa;
TosaSerializationBasicBlock* CreateEmptyTosaSerializationBasicBlock()
{
// Empty basic block when no TOSA mapping implemented/exists
auto* op = new TosaSerializationOperator(Op_UNKNOWN, Attribute_NONE, nullptr, {}, {});
return new TosaSerializationBasicBlock("", "", {op}, {}, {}, {});
}
TosaSerializationBasicBlock* GetTosaMapping(const Layer* layer,
const LayerType type,
const std::vector<const TensorInfo*>& inputs,
const std::vector<const TensorInfo*>& outputs,
const BaseDescriptor& descriptor)
{
switch (type)
{
case LayerType::Activation:
{
auto activationDesc = PolymorphicDowncast<const ActivationDescriptor*>(&descriptor);
if (activationDesc->m_Function == ActivationFunction::LeakyReLu)
{
return ConvertActivationToTosaOperator(layer, inputs, outputs, activationDesc);
}
else
{
return CreateEmptyTosaSerializationBasicBlock();
}
}
case LayerType::Addition:
case LayerType::Multiplication:
case LayerType::Subtraction:
{
return ConvertElementwiseBinaryToTosaOperator(layer, type, inputs, outputs);
}
case LayerType::ElementwiseBinary:
{
auto binaryDesc = PolymorphicDowncast<const ElementwiseBinaryDescriptor*>(&descriptor);
return ConvertElementwiseBinaryToTosaOperator(layer, type, inputs, outputs, binaryDesc);
}
case LayerType::ElementwiseUnary:
{
auto unaryDesc = PolymorphicDowncast<const ElementwiseUnaryDescriptor*>(&descriptor);
return ConvertElementwiseUnaryOperator(layer, inputs, outputs, unaryDesc);
}
case LayerType::Concat:
{
auto concatDesc = PolymorphicDowncast<const OriginsDescriptor*>(&descriptor);
return ConvertConcatToTosaOperator(layer, inputs, outputs, concatDesc);
}
case LayerType::Constant:
{
return ConvertConstantToTosaOperator(layer, outputs);
}
case LayerType::Convolution2d:
{
auto conv2dDesc = PolymorphicDowncast<const Convolution2dDescriptor*>(&descriptor);
return ConvertConv2dToTosaOperator(layer, inputs, outputs, conv2dDesc);
}
case LayerType::Pooling2d:
{
auto poolDesc = PolymorphicDowncast<const Pooling2dDescriptor*>(&descriptor);
bool avgPoolIgnoreValue =
(poolDesc->m_PoolType == PoolingAlgorithm::Average) &&
(poolDesc->m_PaddingMethod == PaddingMethod::IgnoreValue);
if (poolDesc->m_PoolType == PoolingAlgorithm::L2)
{
return CreateEmptyTosaSerializationBasicBlock();
}
else if (avgPoolIgnoreValue)
{
return ConvertAvgPool2DIgnoreValueToTosaOperator(layer, inputs, outputs, poolDesc);
}
else
{
return ConvertPooling2DToTosaOperator(layer, inputs, outputs, poolDesc);
}
}
case LayerType::Quantize:
{
return ConvertQuantizeToTosaOperator(layer, inputs, outputs);
}
case LayerType::Reshape:
{
auto reshapeDesc = PolymorphicDowncast<const ReshapeDescriptor*>(&descriptor);
return ConvertReshapeToTosaOperator(layer, inputs, outputs, reshapeDesc);
}
case LayerType::Resize:
{
auto resizeDesc = PolymorphicDowncast<const ResizeDescriptor*>(&descriptor);
return ConvertResizeToTosaOperator(layer, inputs, outputs, resizeDesc);
}
case LayerType::Slice:
{
auto sliceDesc = PolymorphicDowncast<const SliceDescriptor*>(&descriptor);
return ConvertSliceToTosaOperator(layer, inputs, outputs, sliceDesc);
}
case LayerType::Splitter:
{
auto splitDesc = PolymorphicDowncast<const SplitterDescriptor*>(&descriptor);
return ConvertSplitToTosaOperator(layer, inputs, outputs, splitDesc);
}
case LayerType::TransposeConvolution2d:
{
auto transposeConv2dDesc = PolymorphicDowncast<const TransposeConvolution2dDescriptor*>(&descriptor);
return ConvertTransposeConv2dToTosaOperator(layer, inputs, outputs, transposeConv2dDesc);
}
case LayerType::Transpose:
{
auto transposeDesc = PolymorphicDowncast<const TransposeDescriptor*>(&descriptor);
return ConvertTransposeToTosaOperator(layer, inputs, outputs, transposeDesc);
}
default:
{
return CreateEmptyTosaSerializationBasicBlock();
}
}
}
TosaSerializationBasicBlock* GetTosaMappingFromLayer(Layer* layer)
{
std::vector<const TensorInfo*> inputs;
for (auto inputSlot : layer->GetInputSlots())
{
inputs.push_back(&inputSlot.GetTensorInfo());
}
std::vector<const TensorInfo*> outputs;
for (auto& outputSlot : layer->GetOutputSlots())
{
outputs.push_back(&outputSlot.GetTensorInfo());
}
TosaSerializationBasicBlock* basicBlock = GetTosaMapping(layer,
layer->GetType(),
inputs,
outputs,
layer->GetParameters());
return basicBlock;
}
|
