aboutsummaryrefslogtreecommitdiff
path: root/src/armnnDeserializer
diff options
context:
space:
mode:
Diffstat (limited to 'src/armnnDeserializer')
-rw-r--r--src/armnnDeserializer/Deserializer.cpp73
-rw-r--r--src/armnnDeserializer/test/DeserializeConvolution2d.cpp182
2 files changed, 231 insertions, 24 deletions
diff --git a/src/armnnDeserializer/Deserializer.cpp b/src/armnnDeserializer/Deserializer.cpp
index 704b6c35c1..04dde73b20 100644
--- a/src/armnnDeserializer/Deserializer.cpp
+++ b/src/armnnDeserializer/Deserializer.cpp
@@ -1423,44 +1423,69 @@ void IDeserializer::DeserializerImpl::ParseConvolution2d(GraphPtr graph, unsigne
CHECK_LAYERS(graph, 0, layerIndex);
auto inputs = GetInputs(graph, layerIndex);
CHECK_LOCATION();
- CHECK_VALID_SIZE(inputs.size(), 1);
auto outputs = GetOutputs(graph, layerIndex);
CHECK_VALID_SIZE(outputs.size(), 1);
- auto serializerLayer = graph->layers()->Get(layerIndex)->layer_as_Convolution2dLayer();
+ auto flatBufferLayer = graph->layers()->Get(layerIndex)->layer_as_Convolution2dLayer();
+
auto layerName = GetLayerName(graph, layerIndex);
- auto serializerDescriptor = serializerLayer->descriptor();
+ auto flatbufferDescriptor = flatBufferLayer->descriptor();
armnn::Convolution2dDescriptor descriptor;
- descriptor.m_PadLeft = serializerDescriptor->padLeft();
- descriptor.m_PadRight = serializerDescriptor->padRight();
- descriptor.m_PadTop = serializerDescriptor->padTop();
- descriptor.m_PadBottom = serializerDescriptor->padBottom();
- descriptor.m_StrideX = serializerDescriptor->strideX();
- descriptor.m_StrideY = serializerDescriptor->strideY();;
- descriptor.m_DilationX = serializerDescriptor->dilationX();
- descriptor.m_DilationY = serializerDescriptor->dilationY();;
- descriptor.m_BiasEnabled = serializerDescriptor->biasEnabled();;
- descriptor.m_DataLayout = ToDataLayout(serializerDescriptor->dataLayout());
+ descriptor.m_PadLeft = flatbufferDescriptor->padLeft();
+ descriptor.m_PadRight = flatbufferDescriptor->padRight();
+ descriptor.m_PadTop = flatbufferDescriptor->padTop();
+ descriptor.m_PadBottom = flatbufferDescriptor->padBottom();
+ descriptor.m_StrideX = flatbufferDescriptor->strideX();
+ descriptor.m_StrideY = flatbufferDescriptor->strideY();;
+ descriptor.m_DilationX = flatbufferDescriptor->dilationX();
+ descriptor.m_DilationY = flatbufferDescriptor->dilationY();;
+ descriptor.m_BiasEnabled = flatbufferDescriptor->biasEnabled();;
+ descriptor.m_DataLayout = ToDataLayout(flatbufferDescriptor->dataLayout());
- armnn::ConstTensor weights = ToConstTensor(serializerLayer->weights());
- armnn::ConstTensor biases;
+ armnn::IConnectableLayer* layer;
+ std::vector<unsigned int> ignoreSlots {};
- armnn::Optional<armnn::ConstTensor> optionalBiases = armnn::EmptyOptional();
- if (descriptor.m_BiasEnabled)
+ armnn::ConstTensor biasTensor;
+ // Weights and biases used to be always constant and were stored as members of the layer. This has changed and
+ // they are now passed as inputs. If they are constant then they will be stored in a ConstantLayer.
+ if (this->GetFeatureVersions(graph).m_ConstTensorsAsInputs <= 0)
+ {
+ // If the model stores weights and biases as members of the layer we have to read them from there
+ // but add them to their own ConstantLayer for compatibility
+ CHECK_VALID_SIZE(inputs.size(), 1);
+
+ layer = m_Network->AddConvolution2dLayer(descriptor,
+ layerName.c_str());
+
+ armnn::ConstTensor weightsTensor = ToConstTensor(flatBufferLayer->weights());
+ auto weightsLayer = m_Network->AddConstantLayer(weightsTensor);
+ weightsLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(1u));
+ weightsLayer->GetOutputSlot(0).SetTensorInfo(weightsTensor.GetInfo());
+ ignoreSlots.emplace_back(1u);
+
+ if (descriptor.m_BiasEnabled)
+ {
+ biasTensor = ToConstTensor(flatBufferLayer->biases());
+ auto biasLayer = m_Network->AddConstantLayer(biasTensor);
+ biasLayer->GetOutputSlot(0).Connect(layer->GetInputSlot(2u));
+ biasLayer->GetOutputSlot(0).SetTensorInfo(biasTensor.GetInfo());
+ ignoreSlots.emplace_back(2u);
+ }
+ }
+ else
{
- biases = ToConstTensor(serializerLayer->biases());
- optionalBiases = armnn::Optional<armnn::ConstTensor>(biases);
+ layer = m_Network->AddConvolution2dLayer(descriptor,
+ layerName.c_str());
+ uint32_t numInputs = descriptor.GetNumInputs();
+ CHECK_VALID_SIZE(inputs.size(), numInputs);
}
- IConnectableLayer* layer = m_Network->AddConvolution2dLayer(descriptor,
- weights,
- optionalBiases,
- layerName.c_str());
+
armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
- RegisterInputSlots(graph, layerIndex, layer);
+ RegisterInputSlots(graph, layerIndex, layer, ignoreSlots);
RegisterOutputSlots(graph, layerIndex, layer);
}
diff --git a/src/armnnDeserializer/test/DeserializeConvolution2d.cpp b/src/armnnDeserializer/test/DeserializeConvolution2d.cpp
index 6461250570..e099597845 100644
--- a/src/armnnDeserializer/test/DeserializeConvolution2d.cpp
+++ b/src/armnnDeserializer/test/DeserializeConvolution2d.cpp
@@ -121,6 +121,171 @@ struct Convolution2dFixture : public ParserFlatbuffersSerializeFixture
}
};
+struct Convolution2dFixtureConstantAsInput : public ParserFlatbuffersSerializeFixture
+{
+ explicit Convolution2dFixtureConstantAsInput(const std::string & inputShape1,
+ const std::string & outputShape,
+ const std::string & weightsShape,
+ const std::string & dataType)
+ {
+ m_JsonString = R"(
+ {
+ inputIds: [0],
+ outputIds: [3],
+ layers: [{
+ layer_type: "InputLayer",
+ layer: {
+ base: {
+ layerBindingId: 0,
+ base: {
+ index: 0,
+ layerName: "InputLayer",
+ layerType: "Input",
+ inputSlots: [{
+ index: 0,
+ connection: {sourceLayerIndex:0, outputSlotIndex:0 },
+ }],
+ outputSlots: [{
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + inputShape1 + R"(,
+ dataType: )" + dataType + R"(,
+ quantizationScale: 0.5,
+ quantizationOffset: 0
+ },
+ }]
+ },
+ }
+ },
+ },
+ {
+ layer_type: "Convolution2dLayer",
+ layer : {
+ base: {
+ index:1,
+ layerName: "Convolution2dLayer",
+ layerType: "Convolution2d",
+ inputSlots: [
+ {
+ index: 0,
+ connection: {sourceLayerIndex:0, outputSlotIndex:0 },
+ },
+ {
+ index: 1,
+ connection: {
+ sourceLayerIndex: 2,
+ outputSlotIndex: 0
+ }
+ }
+ ],
+ outputSlots: [
+ {
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + outputShape + R"(,
+ dataType: )" + dataType + R"(
+ },
+ }
+ ],
+ },
+ descriptor: {
+ padLeft: 1,
+ padRight: 1,
+ padTop: 1,
+ padBottom: 1,
+ strideX: 2,
+ strideY: 2,
+ biasEnabled: false,
+ dataLayout: NHWC
+ }
+ }
+ },
+ {
+ layer_type: "ConstantLayer",
+ layer: {
+ base: {
+ index: 2,
+ layerName: "Weights",
+ layerType: "Constant",
+ inputSlots: [
+
+ ],
+ outputSlots: [
+ {
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + weightsShape + R"(,
+ dataType: )" + dataType + R"(,
+ quantizationScale: 0.1,
+ dimensionSpecificity: [
+ true,
+ true,
+ true,
+ true
+ ]
+ }
+ }
+ ]
+ },
+ input: {
+ info: {
+ dimensions: )" + weightsShape + R"(,
+ dataType: )" + dataType + R"(,
+ quantizationScale: 0.1,
+ dimensionSpecificity: [
+ true,
+ true,
+ true,
+ true
+ ]
+ },
+ data_type: "IntData",
+ data: {
+ data: [
+ 1082130432, 1084227584, 1086324736,
+ 0 ,0 ,0 ,
+ 1077936128, 1073741824, 1065353216
+ ]
+ }
+ }
+ }
+ },
+ {
+ layer_type: "OutputLayer",
+ layer: {
+ base:{
+ layerBindingId: 0,
+ base: {
+ index: 3,
+ layerName: "OutputLayer",
+ layerType: "Output",
+ inputSlots: [{
+ index: 0,
+ "connection": {
+ "sourceLayerIndex": 1,
+ "outputSlotIndex": 0
+ }
+ }],
+ outputSlots: [ {
+ index: 0,
+ tensorInfo: {
+ dimensions: )" + outputShape + R"(,
+ dataType: )" + dataType + R"(
+ },
+ }],
+ }
+ }},
+ }],
+ "featureVersions": {
+ "constantTensorsAsInputs": 1,
+ "weightsLayoutScheme": 1
+ }
+ }
+ )";
+ Setup();
+ }
+};
+
struct SimpleConvolution2dFixture : Convolution2dFixture
{
SimpleConvolution2dFixture() : Convolution2dFixture("[ 1, 5, 5, 1 ]",
@@ -137,4 +302,21 @@ TEST_CASE_FIXTURE(SimpleConvolution2dFixture, "Convolution2dFloat32")
{{"OutputLayer", {23, 33, 24, 91, 99, 48, 26, 50, 19}}});
}
+
+struct SimpleConvolution2dFixtureConstantAsInput : Convolution2dFixtureConstantAsInput
+{
+ SimpleConvolution2dFixtureConstantAsInput() : Convolution2dFixtureConstantAsInput("[ 1, 5, 5, 1 ]",
+ "[ 1, 3, 3, 1 ]",
+ "[ 1, 3, 3, 1 ]",
+ "Float32") {}
+};
+
+TEST_CASE_FIXTURE(SimpleConvolution2dFixtureConstantAsInput, "Convolution2dFloat32ConstAsInput")
+{
+ RunTest<4, armnn::DataType::Float32>(
+ 0,
+ {{"InputLayer", {1, 5, 2, 3, 5, 8, 7, 3, 6, 3, 3, 3, 9, 1, 9, 4, 1, 8, 1, 3, 6, 8, 1, 9, 2}}},
+ {{"OutputLayer", {23, 33, 24, 91, 99, 48, 26, 50, 19}}});
+}
+
}
generated by cgit v1.2.1 (git 2.23.0) at 2024-06-01 05:18:33 +0000