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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
|
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#pragma once
#include <armnn/ILayerVisitor.hpp>
#include <armnn/IStrategy.hpp>
#include <armnn/LayerVisitorBase.hpp>
#include <armnnSerializer/ISerializer.hpp>
#include <common/include/ProfilingGuid.hpp>
#include <unordered_map>
#include "ArmnnSchema_generated.h"
#include <armnn/Types.hpp>
namespace armnnSerializer
{
class SerializerStrategy : public armnn::IStrategy
{
public:
void ExecuteStrategy(const armnn::IConnectableLayer* layer,
const armnn::BaseDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name,
const armnn::LayerBindingId id) override;
SerializerStrategy() : m_layerId(0) {}
~SerializerStrategy() {}
flatbuffers::FlatBufferBuilder& GetFlatBufferBuilder()
{
return m_flatBufferBuilder;
}
std::vector<int>& GetInputIds()
{
return m_inputIds;
}
std::vector<int>& GetOutputIds()
{
return m_outputIds;
}
std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>>& GetSerializedLayers()
{
return m_serializedLayers;
}
flatbuffers::Offset<armnnSerializer::FeatureCompatibilityVersions> GetVersionTable();
private:
/// Creates the Input Slots and Output Slots and LayerBase for the layer.
flatbuffers::Offset<armnnSerializer::LayerBase> CreateLayerBase(
const armnn::IConnectableLayer* layer,
const armnnSerializer::LayerType layerType);
/// Creates the serializer AnyLayer for the layer and adds it to m_serializedLayers.
void CreateAnyLayer(const flatbuffers::Offset<void>& layer, const armnnSerializer::Layer serializerLayer);
/// Creates the serializer ConstTensor for the armnn ConstTensor.
flatbuffers::Offset<armnnSerializer::ConstTensor> CreateConstTensorInfo(
const armnn::ConstTensor& constTensor);
/// Creates the serializer TensorInfo for the armnn TensorInfo.
flatbuffers::Offset<TensorInfo> CreateTensorInfo(const armnn::TensorInfo& tensorInfo);
template <typename T>
flatbuffers::Offset<flatbuffers::Vector<T>> CreateDataVector(const void* memory, unsigned int size);
///Function which maps Guid to an index
uint32_t GetSerializedId(LayerGuid guid);
/// Creates the serializer InputSlots for the layer.
std::vector<flatbuffers::Offset<armnnSerializer::InputSlot>> CreateInputSlots(
const armnn::IConnectableLayer* layer);
/// Creates the serializer OutputSlots for the layer.
std::vector<flatbuffers::Offset<armnnSerializer::OutputSlot>> CreateOutputSlots(
const armnn::IConnectableLayer* layer);
/// FlatBufferBuilder to create our layers' FlatBuffers.
flatbuffers::FlatBufferBuilder m_flatBufferBuilder;
/// AnyLayers required by the SerializedGraph.
std::vector<flatbuffers::Offset<armnnSerializer::AnyLayer>> m_serializedLayers;
/// Vector of the binding ids of all Input Layers required by the SerializedGraph.
std::vector<int> m_inputIds;
/// Vector of the binding ids of all Output Layers required by the SerializedGraph.
std::vector<int> m_outputIds;
/// Mapped Guids of all Layers to match our index.
std::unordered_map<LayerGuid, uint32_t > m_guidMap;
/// layer within our FlatBuffer index.
uint32_t m_layerId;
private:
void SerializeActivationLayer(const armnn::IConnectableLayer* layer,
const armnn::ActivationDescriptor& descriptor,
const char* name = nullptr);
void SerializeAdditionLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeArgMinMaxLayer(const armnn::IConnectableLayer* layer,
const armnn::ArgMinMaxDescriptor& argMinMaxDescriptor,
const char* name = nullptr);
void SerializeBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
const armnn::BatchToSpaceNdDescriptor& descriptor,
const char* name = nullptr);
void SerializeBatchNormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::BatchNormalizationDescriptor& BatchNormalizationDescriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeCastLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeChannelShuffleLayer(const armnn::IConnectableLayer* layer,
const armnn::ChannelShuffleDescriptor& descriptor,
const char* name = nullptr);
void SerializeComparisonLayer(const armnn::IConnectableLayer* layer,
const armnn::ComparisonDescriptor& descriptor,
const char* name = nullptr);
void SerializeConcatLayer(const armnn::IConnectableLayer* layer,
const armnn::ConcatDescriptor& concatDescriptor,
const char* name = nullptr);
void SerializeConstantLayer(const armnn::IConnectableLayer* layer,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeConvolution2dLayer(const armnn::IConnectableLayer* layer,
const armnn::Convolution2dDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeConvolution3dLayer(const armnn::IConnectableLayer* layer,
const armnn::Convolution3dDescriptor& descriptor,
const char* name = nullptr);
void SerializeDepthToSpaceLayer(const armnn::IConnectableLayer* layer,
const armnn::DepthToSpaceDescriptor& descriptor,
const char* name = nullptr);
void SerializeDepthwiseConvolution2dLayer(const armnn::IConnectableLayer* layer,
const armnn::DepthwiseConvolution2dDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeDequantizeLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeDetectionPostProcessLayer(const armnn::IConnectableLayer* layer,
const armnn::DetectionPostProcessDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeDivisionLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeElementwiseUnaryLayer(const armnn::IConnectableLayer* layer,
const armnn::ElementwiseUnaryDescriptor& descriptor,
const char* name = nullptr);
void SerializeFillLayer(const armnn::IConnectableLayer* layer,
const armnn::FillDescriptor& fillDescriptor,
const char* name = nullptr);
void SerializeFloorLayer(const armnn::IConnectableLayer *layer,
const char *name = nullptr);
void SerializeFullyConnectedLayer(const armnn::IConnectableLayer* layer,
const armnn::FullyConnectedDescriptor& fullyConnectedDescriptor,
const char* name = nullptr);
void SerializeGatherLayer(const armnn::IConnectableLayer* layer,
const armnn::GatherDescriptor& gatherDescriptor,
const char* name = nullptr);
void SerializeInputLayer(const armnn::IConnectableLayer* layer,
armnn::LayerBindingId id,
const char* name = nullptr);
void SerializeInstanceNormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::InstanceNormalizationDescriptor& instanceNormalizationDescriptor,
const char* name = nullptr);
void SerializeL2NormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::L2NormalizationDescriptor& l2NormalizationDescriptor,
const char* name = nullptr);
void SerializeLogicalBinaryLayer(const armnn::IConnectableLayer* layer,
const armnn::LogicalBinaryDescriptor& descriptor,
const char* name = nullptr);
void SerializeLogSoftmaxLayer(const armnn::IConnectableLayer* layer,
const armnn::LogSoftmaxDescriptor& logSoftmaxDescriptor,
const char* name = nullptr);
void SerializeLstmLayer(const armnn::IConnectableLayer* layer,
const armnn::LstmDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeMeanLayer(const armnn::IConnectableLayer* layer,
const armnn::MeanDescriptor& descriptor,
const char* name);
void SerializeMinimumLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeMaximumLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeMergeLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeMultiplicationLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeOutputLayer(const armnn::IConnectableLayer* layer,
armnn::LayerBindingId id,
const char* name = nullptr);
void SerializePadLayer(const armnn::IConnectableLayer* layer,
const armnn::PadDescriptor& PadDescriptor,
const char* name = nullptr);
void SerializePermuteLayer(const armnn::IConnectableLayer* layer,
const armnn::PermuteDescriptor& PermuteDescriptor,
const char* name = nullptr);
void SerializePooling2dLayer(const armnn::IConnectableLayer* layer,
const armnn::Pooling2dDescriptor& pooling2dDescriptor,
const char* name = nullptr);
void SerializePooling3dLayer(const armnn::IConnectableLayer* layer,
const armnn::Pooling3dDescriptor& pooling3dDescriptor,
const char* name = nullptr);
void SerializePreluLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeQuantizeLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeQLstmLayer(const armnn::IConnectableLayer* layer,
const armnn::QLstmDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeQuantizedLstmLayer(const armnn::IConnectableLayer* layer,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
void SerializeRankLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeReduceLayer(const armnn::IConnectableLayer* layer,
const armnn::ReduceDescriptor& reduceDescriptor,
const char* name = nullptr);
void SerializeReshapeLayer(const armnn::IConnectableLayer* layer,
const armnn::ReshapeDescriptor& reshapeDescriptor,
const char* name = nullptr);
void SerializeResizeLayer(const armnn::IConnectableLayer* layer,
const armnn::ResizeDescriptor& resizeDescriptor,
const char* name = nullptr);
void SerializeSliceLayer(const armnn::IConnectableLayer* layer,
const armnn::SliceDescriptor& sliceDescriptor,
const char* name = nullptr);
void SerializeSoftmaxLayer(const armnn::IConnectableLayer* layer,
const armnn::SoftmaxDescriptor& softmaxDescriptor,
const char* name = nullptr);
void SerializeSpaceToBatchNdLayer(const armnn::IConnectableLayer* layer,
const armnn::SpaceToBatchNdDescriptor& spaceToBatchNdDescriptor,
const char* name = nullptr);
void SerializeSpaceToDepthLayer(const armnn::IConnectableLayer* layer,
const armnn::SpaceToDepthDescriptor& spaceToDepthDescriptor,
const char* name = nullptr);
void SerializeNormalizationLayer(const armnn::IConnectableLayer* layer,
const armnn::NormalizationDescriptor& normalizationDescriptor,
const char* name = nullptr);
void SerializeShapeLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeSplitterLayer(const armnn::IConnectableLayer* layer,
const armnn::ViewsDescriptor& viewsDescriptor,
const char* name = nullptr);
void SerializeStandInLayer(const armnn::IConnectableLayer* layer,
const armnn::StandInDescriptor& standInDescriptor,
const char* name = nullptr);
void SerializeStackLayer(const armnn::IConnectableLayer* layer,
const armnn::StackDescriptor& stackDescriptor,
const char* name = nullptr);
void SerializeStridedSliceLayer(const armnn::IConnectableLayer* layer,
const armnn::StridedSliceDescriptor& stridedSliceDescriptor,
const char* name = nullptr);
void SerializeSubtractionLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeSwitchLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr);
void SerializeTransposeConvolution2dLayer(const armnn::IConnectableLayer* layer,
const armnn::TransposeConvolution2dDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* = nullptr);
void SerializeTransposeLayer(const armnn::IConnectableLayer* layer,
const armnn::TransposeDescriptor& descriptor,
const char* name = nullptr);
void SerializeUnidirectionalSequenceLstmLayer(const armnn::IConnectableLayer* layer,
const armnn::UnidirectionalSequenceLstmDescriptor& descriptor,
const std::vector<armnn::ConstTensor>& constants,
const char* name = nullptr);
};
class ISerializer::SerializerImpl
{
public:
SerializerImpl() = default;
~SerializerImpl() = default;
/// Serializes the network to ArmNN SerializedGraph.
/// @param [in] inNetwork The network to be serialized.
void Serialize(const armnn::INetwork& inNetwork);
/// Serializes the SerializedGraph to the stream.
/// @param [stream] the stream to save to
/// @return true if graph is Serialized to the Stream, false otherwise
bool SaveSerializedToStream(std::ostream& stream);
private:
/// Visitor to contruct serialized network
SerializerStrategy m_SerializerStrategy;
};
} //namespace armnnSerializer
|
