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
|
//
// Copyright © 2017 Arm Ltd and Contributors. All rights reserved.
// SPDX-License-Identifier: MIT
//
#include "FullyConnectedLayer.hpp"
#include "LayerCloneBase.hpp"
#include <armnn/TypesUtils.hpp>
#include <backendsCommon/TensorHandle.hpp>
#include <backendsCommon/WorkloadData.hpp>
#include <backendsCommon/WorkloadFactory.hpp>
namespace armnn
{
FullyConnectedLayer::FullyConnectedLayer(const FullyConnectedDescriptor& param, const char* name)
: LayerWithParameters(param.GetNumViews(), 1, LayerType::FullyConnected, param, name)
{
}
std::unique_ptr<IWorkload> FullyConnectedLayer::CreateWorkload(const IWorkloadFactory& factory) const
{
// on this level constant data should not be released..
FullyConnectedQueueDescriptor descriptor;
if (m_Param.m_ConstantWeights)
{
ARMNN_ASSERT_MSG(m_Weight != nullptr, "FullyConnectedLayer: Weights data should not be null.");
descriptor.m_Weight = m_Weight.get();
if (m_Param.m_BiasEnabled)
{
ARMNN_ASSERT_MSG(m_Bias != nullptr, "FullyConnectedLayer: Bias data should not be null.");
descriptor.m_Bias = m_Bias.get();
}
}
SetAdditionalInfo(descriptor);
return factory.CreateFullyConnected(descriptor, PrepInfoAndDesc(descriptor));
}
FullyConnectedLayer* FullyConnectedLayer::Clone(Graph& graph) const
{
auto layer = CloneBase<FullyConnectedLayer>(graph, m_Param, GetName());
if (m_Param.m_ConstantWeights)
{
layer->m_Weight = m_Weight ? m_Weight : nullptr;
if (layer->m_Param.m_BiasEnabled)
{
layer->m_Bias = m_Bias ? m_Bias : nullptr;
}
}
return std::move(layer);
}
std::vector<TensorShape> FullyConnectedLayer::InferOutputShapes(const std::vector<TensorShape>& inputShapes) const
{
ARMNN_ASSERT(inputShapes.size() == 2);
const TensorShape& inputShape = inputShapes[0];
const TensorShape weightShape = inputShapes[1];
// Output for FC is [1, w[1]].
unsigned int batches = inputShape[0];
unsigned int dimIdx = m_Param.m_TransposeWeightMatrix ? 0 : 1;
return std::vector<TensorShape>({ TensorShape({batches, weightShape[dimIdx]})});
}
void FullyConnectedLayer::ValidateTensorShapesFromInputs()
{
const TensorShape& outputShape = GetOutputSlot(0).GetTensorInfo().GetShape();
VerifyShapeInferenceType(outputShape, m_ShapeInferenceMethod);
std::vector<TensorShape> inferredShapes;
if (m_Param.m_ConstantWeights)
{
// check if m_Weight data is not nullptr
ARMNN_ASSERT_MSG(m_Weight != nullptr, "FullyConnectedLayer: Weights data should not be null.");
inferredShapes = InferOutputShapes({GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(),
m_Weight->GetTensorInfo().GetShape()});
}
else
{
inferredShapes = InferOutputShapes({GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape(),
GetInputSlot(1).GetConnection()->GetTensorInfo().GetShape()});
}
ARMNN_ASSERT(inferredShapes.size() == 1);
ARMNN_ASSERT(inferredShapes[0].GetDimensionality() == Dimensionality::Specified);
ValidateAndCopyShape(outputShape, inferredShapes[0], m_ShapeInferenceMethod, "FullyConnectedLayer");
}
Layer::ConstantTensors FullyConnectedLayer::GetConstantTensorsByRef()
{
return {m_Weight, m_Bias};
}
void FullyConnectedLayer::Accept(ILayerVisitor& visitor) const
{
Optional<ConstTensor> optionalWeightsTensor = EmptyOptional();
Optional<ConstTensor> optionalBiasTensor = EmptyOptional();
ManagedConstTensorHandle managedWeight(m_Weight);
ManagedConstTensorHandle managedBias(m_Bias);
if (GetParameters().m_ConstantWeights)
{
ConstTensor weightsTensor(managedWeight.GetTensorInfo(), managedWeight.Map());
optionalWeightsTensor = Optional<ConstTensor>(weightsTensor);
if (GetParameters().m_BiasEnabled)
{
ConstTensor biasTensor(managedBias.GetTensorInfo(), managedBias.Map());
optionalBiasTensor = Optional<ConstTensor>(biasTensor);
}
}
visitor.VisitFullyConnectedLayer(this,
GetParameters(),
optionalWeightsTensor.value(),
optionalBiasTensor,
GetName());
}
void FullyConnectedLayer::ExecuteStrategy(IStrategy& strategy) const
{
std::vector <armnn::ConstTensor> constTensors;
ManagedConstTensorHandle managedWeight(m_Weight);
ManagedConstTensorHandle managedBias(m_Bias);
if(GetParameters().m_ConstantWeights)
{
constTensors.emplace_back(ConstTensor(managedWeight.GetTensorInfo(), managedWeight.Map()));
if (GetParameters().m_BiasEnabled)
{
constTensors.emplace_back(ConstTensor(managedBias.GetTensorInfo(), managedBias.Map()));
}
}
strategy.ExecuteStrategy(this, GetParameters(), constTensors, GetName());
}
} // namespace armnn
|
