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
|
//
// Copyright © 2017 Arm Ltd. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "Network.hpp"
#include "QuantizerVisitor.hpp"
#include "StaticRangeVisitor.hpp"
#include "NetworkQuantizerUtils.hpp"
namespace armnn
{
QuantizerVisitor::QuantizerVisitor(const StaticRangeVisitor* staticRangeVisitor)
: m_StaticRangeVisitor(staticRangeVisitor)
, m_QuantizedNetwork(INetwork::Create())
{
BOOST_ASSERT(m_StaticRangeVisitor);
}
void QuantizerVisitor::SetQuantizedInputConnections(const IConnectableLayer* srcLayer,
IConnectableLayer* quantizedLayer)
{
for (unsigned int i = 0; i < srcLayer->GetNumInputSlots(); i++)
{
const IInputSlot& srcInputSlot = srcLayer->GetInputSlot(i);
const InputSlot* inputSlot = boost::polymorphic_downcast<const InputSlot*>(&srcInputSlot);
const OutputSlot* outputSlot = inputSlot->GetConnectedOutputSlot();
unsigned int slotIdx = outputSlot->CalculateIndexOnOwner();
Layer& layerToFind = outputSlot->GetOwningLayer();
auto found = m_OriginalToQuantizedGuidMap.find(layerToFind.GetGuid());
if (found == m_OriginalToQuantizedGuidMap.end())
{
// Error in graph traversal order
BOOST_ASSERT_MSG(false, "Error in graph traversal");
return;
}
// Connect the slots in the quantized model
IConnectableLayer* prevQuantizedLayer = m_QuantizedGuidToLayerMap[found->second];
IInputSlot& newInputSlot = quantizedLayer->GetInputSlot(i);
IOutputSlot& newOutputSlot = prevQuantizedLayer->GetOutputSlot(slotIdx);
newOutputSlot.Connect(newInputSlot);
// Fetch the min/max ranges that were computed earlier
auto range = m_StaticRangeVisitor->GetRange(layerToFind.GetGuid(), i);
auto qParams = ComputeQAsymmParams(8, range.first, range.second);
// Set the quantization params
TensorInfo info(newOutputSlot.GetTensorInfo());
info.SetDataType(DataType::QuantisedAsymm8);
info.SetQuantizationOffset(qParams.first);
info.SetQuantizationScale(qParams.second);
newOutputSlot.SetTensorInfo(info);
}
}
void QuantizerVisitor::RecordLayer(const IConnectableLayer* srcLayer, IConnectableLayer* quantizedLayer)
{
m_OriginalToQuantizedGuidMap[srcLayer->GetGuid()] = quantizedLayer->GetGuid();
m_QuantizedGuidToLayerMap[quantizedLayer->GetGuid()] = quantizedLayer;
}
void QuantizerVisitor::VisitAdditionLayer(const IConnectableLayer* layer, const char* name)
{
IConnectableLayer* newLayer = m_QuantizedNetwork->AddAdditionLayer(name);
RecordLayer(layer, newLayer);
SetQuantizedInputConnections(layer, newLayer);
}
void QuantizerVisitor::VisitActivationLayer(const IConnectableLayer* layer,
const ActivationDescriptor& activationDescriptor,
const char* name)
{
IConnectableLayer* newLayer = m_QuantizedNetwork->AddActivationLayer(activationDescriptor, name);
RecordLayer(layer, newLayer);
SetQuantizedInputConnections(layer, newLayer);
}
void QuantizerVisitor::VisitInputLayer(const IConnectableLayer* layer, LayerBindingId id, const char* name)
{
IConnectableLayer* newLayer = m_QuantizedNetwork->AddInputLayer(id, name);
RecordLayer(layer, newLayer);
}
void QuantizerVisitor::VisitOutputLayer(const IConnectableLayer* layer, LayerBindingId id, const char* name)
{
IConnectableLayer* newLayer = m_QuantizedNetwork->AddOutputLayer(id, name);
RecordLayer(layer, newLayer);
SetQuantizedInputConnections(layer, newLayer);
}
void QuantizerVisitor::VisitBatchNormalizationLayer(const IConnectableLayer* layer,
const BatchNormalizationDescriptor& desc,
const ConstTensor& mean,
const ConstTensor& variance,
const ConstTensor& beta,
const ConstTensor& gamma,
const char* name)
{
std::vector<uint8_t> meanBacking;
ConstTensor qMean = CreateQuantizedConst(mean, meanBacking);
std::vector<uint8_t> varianceBacking;
ConstTensor qVariance = CreateQuantizedConst(variance, varianceBacking);
std::vector<uint8_t> betaBacking;
ConstTensor qBeta = CreateQuantizedConst(beta, betaBacking);
std::vector<uint8_t> gammaBacking;
ConstTensor qGamma = CreateQuantizedConst(variance, gammaBacking);
IConnectableLayer* newLayer = m_QuantizedNetwork->AddBatchNormalizationLayer(desc,
qMean,
qVariance,
qBeta,
qGamma,
name);
RecordLayer(layer, newLayer);
SetQuantizedInputConnections(layer, newLayer);
}
} //namespace armnn
|
