25 #include <boost/test/unit_test.hpp> 27 using namespace armnn;
32 void CreateLSTMLayerHelper(
Graph &graph,
bool CifgEnabled)
43 unsigned int batchSize = 3;
44 unsigned int inputSize = 2;
45 unsigned int numUnits = 4;
46 unsigned int outputSize = 4;
77 if (!layerDesc.m_CifgEnabled)
90 if (layerDesc.m_ProjectionEnabled)
100 if (layerDesc.m_PeepholeEnabled)
102 if (!layerDesc.m_CifgEnabled)
129 armnn::TensorInfo lstmTensorInfoScratchBuff({ batchSize, numUnits * (layerDesc.m_CifgEnabled ? 3 : 4) },
132 Connect(input, layer, lstmTensorInfo1, 0, 0);
133 Connect(cellStateIn, layer, lstmTensorInfo2, 0, 1);
134 Connect(outputStateIn, layer, lstmTensorInfo3, 0, 2);
135 Connect(layer, scratchBuffer, lstmTensorInfoScratchBuff, 0, 0);
136 Connect(layer, outputStateOut, lstmTensorInfo3, 1, 0);
137 Connect(layer, cellStateOut, lstmTensorInfo2, 2, 0);
138 Connect(layer, output, lstmTensorInfo3, 3, 0);
151 CreateLSTMLayerHelper(graph,
false);
162 CreateLSTMLayerHelper(graph,
true);
182 ->GetOutputHandler().SetTensorInfo(
info);
191 ->GetOutputHandler().SetTensorInfo(
info);
196 &IsLayerOfType<armnn::InputLayer>,
197 &IsLayerOfType<armnn::InputLayer>,
198 &IsLayerOfType<armnn::MemCopyLayer>,
199 &IsLayerOfType<armnn::FloorLayer>,
200 &IsLayerOfType<armnn::AdditionLayer>,
201 &IsLayerOfType<armnn::OutputLayer>));
204 for (
auto& layer : graph)
214 for (
auto& layer : graph)
224 for (
auto& layer : graph)
246 &IsLayerOfType<armnn::InputLayer>,
247 &IsLayerOfType<armnn::InputLayer>,
248 &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
249 &IsLayerOfType<armnn::MemCopyLayer>,
250 &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
251 &IsLayerOfType<armnn::FloorLayer>,
252 &IsLayerOfType<armnn::ConvertFp32ToFp16Layer>,
253 &IsLayerOfType<armnn::ConvertFp16ToFp32Layer>,
254 &IsLayerOfType<armnn::AdditionLayer>,
255 &IsLayerOfType<armnn::ConvertFp32ToFp16Layer>,
256 &IsLayerOfType<armnn::OutputLayer>));
260 const unsigned int* weightsShape,
const unsigned int* outputShape,
266 std::vector<float> weightsVector(90);
279 layer->
m_Weight = std::make_unique<armnn::ScopedTensorHandle>(weights);
290 const unsigned int inputShape[] = { 1, 3, 8, 16 };
291 const unsigned int weightsShape[] = { 2, 3, 5, 3 };
292 const unsigned int outputShape[] = { 1, 2, 4, 14 };
301 const unsigned int inputShape[] = { 1, 8, 16, 3 };
302 const unsigned int weightsShape[] = { 2, 5, 3, 3 };
303 const unsigned int outputShape[] = { 1, 4, 14, 2 };
310 const unsigned int* weightsShape,
const unsigned int* outputShape,
316 std::vector<float> weightsVector(18);
329 layer->
m_Weight = std::make_unique<armnn::ScopedTensorHandle>(weights);
340 const unsigned int inputShape[] = { 1, 2, 3, 3 };
341 const unsigned int weightsShape[] = { 1, 2, 3, 3 };
342 const unsigned int outputShape[] = { 1, 2, 1, 1 };
351 const unsigned int inputShape[] = { 1, 3, 3, 2 };
352 const unsigned int weightsShape[] = { 1, 2, 3, 3 };
353 const unsigned int outputShape[] = { 1, 1, 1, 2 };
390 const unsigned int inputShape[] = { 5, 3, 52, 60 };
391 const unsigned int outputShape[] = { 5, 3, 11, 13 };
400 const unsigned int inputShape[] = { 5, 52, 60, 3 };
401 const unsigned int outputShape[] = { 5, 11, 13, 3 };
408 const unsigned int* inputShape,
409 const unsigned int* outputShape,
435 const unsigned int inputShape[] = { 1, 2, 4, 5 };
436 const unsigned int outputShape[] = { 1, 2, 3, 4 };
445 const unsigned int inputShape[] = { 1, 4, 5, 2 };
446 const unsigned int outputShape[] = { 1, 3, 4, 2 };
514 std::vector<uint8_t> anchorsVector(40);
538 input0->GetOutputSlot().Connect(layer->
GetInputSlot(0));
547 const unsigned int inputShape[] = { 1, 2, 2, 3 };
548 const unsigned int paddedShape[] = { 1, 6, 6, 3 };
549 const unsigned int weightsShape[] = { 1, 2, 3, 3 };
550 const unsigned int outputShape[] = { 1, 2, 1, 1 };
559 PadDescriptor padDescriptor({ { 0, 0 }, { 2, 2 }, { 2, 2 }, { 0, 0 } });
570 std::vector<float> weightsVector(18);
574 conv2dLayer->
m_Weight = std::make_unique<armnn::ScopedTensorHandle>(weights);
581 padLayer->GetOutputSlot().Connect(conv2dLayer->
GetInputSlot(0));
584 auto checkSimpleConv2d = [](
const armnn::Layer*
const layer) ->
bool {
587 return IsLayerOfType<armnn::Convolution2dLayer>(layer) && (layer->
GetNameStr() ==
"conv2d") &&
588 (conv2dLayerParams.m_PadLeft == 0) && (conv2dLayerParams.m_PadRight == 0) &&
589 (conv2dLayerParams.m_PadTop == 0) && (conv2dLayerParams.m_PadBottom == 0) &&
590 (conv2dLayerParams.m_BiasEnabled ==
false) && (conv2dLayerParams.m_StrideX == 1) &&
591 (conv2dLayerParams.m_StrideY == 1) && (conv2dLayerParams.m_DataLayout ==
DataLayout::NHWC);
595 &IsLayerOfType<armnn::InputLayer>,
596 &IsLayerOfType<armnn::PadLayer>,
598 &IsLayerOfType<armnn::OutputLayer>));
602 auto checkPadFoldedIntoConv2d = [](
const armnn::Layer*
const layer) ->
bool {
605 return IsLayerOfType<armnn::Convolution2dLayer>(layer) && (layer->
GetNameStr() ==
"folded-pad-into-conv2d") &&
606 (conv2dLayerParams.m_PadLeft == 2) && (conv2dLayerParams.m_PadRight == 2) &&
607 (conv2dLayerParams.m_PadTop == 2) && (conv2dLayerParams.m_PadBottom == 2) &&
608 (conv2dLayerParams.m_BiasEnabled ==
false) && (conv2dLayerParams.m_StrideX == 1) &&
609 (conv2dLayerParams.m_StrideY == 1) && (conv2dLayerParams.m_DataLayout ==
DataLayout::NHWC);
613 &IsLayerOfType<armnn::InputLayer>,
614 checkPadFoldedIntoConv2d,
615 &IsLayerOfType<armnn::OutputLayer>));
621 const unsigned int inputShape[] = { 1, 2, 2, 3 };
622 const unsigned int paddedShape[] = { 1, 4, 4, 3 };
623 const unsigned int outputShape[] = { 1, 2, 2, 3 };
632 PadDescriptor padDescriptor({ { 0, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 } });
652 padLayer->GetOutputSlot().Connect(pool2dLayer->
GetInputSlot(0));
655 auto checkSimplePool2d = [&](
const armnn::Layer*
const layer) {
657 return IsLayerOfType<armnn::Pooling2dLayer>(layer) && (layer->
GetNameStr() ==
"pool2d") &&
662 &IsLayerOfType<armnn::InputLayer>,
663 &IsLayerOfType<armnn::PadLayer>,
665 &IsLayerOfType<armnn::OutputLayer>));
669 auto checkPadFoldedIntoPool2d = [&](
const armnn::Layer*
const layer) {
670 if (!IsLayerOfType<armnn::Pooling2dLayer>(layer) || (layer->
GetNameStr() !=
"folded-pad-into-pool2d"))
681 pool2dLayerParamsNoPad.
m_PadTop = 0;
686 return (pool2dLayerParamsNoPad == pooling2dDescriptor) && (pool2dLayerParams.
m_PadLeft == 1) &&
693 &IsLayerOfType<armnn::InputLayer>,
694 checkPadFoldedIntoPool2d,
695 &IsLayerOfType<armnn::OutputLayer>));
704 const unsigned int inputShape[] = { 1, 2, 2, 3 };
705 const unsigned int paddedShape[] = { 1, 4, 4, 3 };
706 const unsigned int outputShape[] = { 1, 2, 2, 3 };
715 PadDescriptor padDescriptor({ { 0, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 } });
735 padLayer->GetOutputSlot().Connect(pool2dLayer->
GetInputSlot(0));
742 auto checkSimplePool2d = [&](
const armnn::Layer*
const layer) {
744 return IsLayerOfType<armnn::Pooling2dLayer>(layer) && (layer->
GetNameStr() ==
"pool2d") &&
750 &IsLayerOfType<armnn::InputLayer>,
751 &IsLayerOfType<armnn::PadLayer>,
753 &IsLayerOfType<armnn::OutputLayer>,
754 &IsLayerOfType<armnn::OutputLayer>));
760 &IsLayerOfType<armnn::InputLayer>,
761 &IsLayerOfType<armnn::PadLayer>,
763 &IsLayerOfType<armnn::OutputLayer>,
764 &IsLayerOfType<armnn::OutputLayer>));
772 const unsigned int inputShape[] = { 1, 2, 2, 3 };
773 const unsigned int paddedShape[] = { 1, 4, 4, 3 };
774 const unsigned int outputShape[] = { 1, 2, 2, 3 };
783 PadDescriptor padDescriptor({ { 0, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 } });
809 padLayer->GetOutputSlot().Connect(pool2dLayer->
GetInputSlot(0));
812 auto checkSimplePool2d = [&](
const armnn::Layer*
const layer) {
814 return IsLayerOfType<armnn::Pooling2dLayer>(layer) && (layer->
GetNameStr() ==
"pool2d") &&
819 &IsLayerOfType<armnn::InputLayer>,
820 &IsLayerOfType<armnn::PadLayer>,
822 &IsLayerOfType<armnn::OutputLayer>));
828 &IsLayerOfType<armnn::InputLayer>,
829 &IsLayerOfType<armnn::PadLayer>,
831 &IsLayerOfType<armnn::OutputLayer>));
839 const unsigned int inputShape[] = { 1, 2, 2, 3 };
840 const unsigned int paddedShape[] = { 1, 4, 4, 3 };
841 const unsigned int outputShape[] = { 1, 2, 2, 3 };
850 PadDescriptor padDescriptor({ { 0, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 } });
876 auto checkSimplePool2d = [&](
const armnn::Layer*
const layer) {
878 return IsLayerOfType<armnn::Pooling2dLayer>(layer) && (layer->
GetNameStr() ==
"pool2d") &&
883 &IsLayerOfType<armnn::InputLayer>,
884 &IsLayerOfType<armnn::PadLayer>,
886 &IsLayerOfType<armnn::OutputLayer>));
892 &IsLayerOfType<armnn::InputLayer>,
893 &IsLayerOfType<armnn::PadLayer>,
895 &IsLayerOfType<armnn::OutputLayer>));
898 #if defined(ARMNNREF_ENABLED) 904 const unsigned int inputShape[] = { 1, 4, 4, 2 };
905 const unsigned int paddedShape[] = { 1, 6, 6, 2 };
906 const unsigned int outputShape[] = { 1, 4, 4, 2 };
907 std::vector<float> inputData({
908 2.0f, 2.0f, 6.0f, 6.0f, 4.0f, 4.0f, 8.0f, 8.0f, 10.0f, 12.0f, 14.0f, 16.0f, 10.0f, 12.0f, 16.0f, 14.0f,
910 18.0f, 20.0f, 24.0f, 22.0f, 20.0f, 18.0f, 22.0f, 24.0f, 26.0f, 28.0f, 0.0f, 0.0f, 26.0f, 28.0f, 0.0f, 0.0f,
921 PadDescriptor padDescriptor({ { 0, 0 }, { 1, 1 }, { 1, 1 }, { 0, 0 } });
924 padLayer->GetOutputSlot(0).SetTensorInfo(paddedInfo);
933 IConnectableLayer* pool2dLayer = network->AddPooling2dLayer(pooling2dDescriptor,
"Pool2D");
941 padLayer->GetOutputSlot(0).Connect(pool2dLayer->
GetInputSlot(0));
950 BOOST_TEST(run->LoadNetwork(networkIdentifier, std::move(optimizedNetwork)) ==
Status::Success);
953 ConstTensor(run->GetInputTensorInfo(networkIdentifier, 0), inputData.data()) } };
956 std::vector<float> optimizedData(32, -std::numeric_limits<float>::infinity());
959 run->EnqueueWorkload(networkIdentifier, inputTensors, outputTensors);
961 run->UnloadNetwork(networkIdentifier);
972 BOOST_TEST(run->LoadNetwork(networkIdentifier, std::move(optimizedNetwork)) ==
Status::Success);
973 std::vector<float> goldenData(32, 0.0f);
974 std::vector<float> padOutputData(72, 0.0f);
977 run->EnqueueWorkload(networkIdentifier, inputTensors, goldenTensors);
980 BOOST_TEST(std::equal(goldenData.begin(), goldenData.end(), optimizedData.begin()));
982 catch (
const std::exception& e)
984 std::cerr << e.what() << std::endl;
1014 template <
typename NamePolicy>
1023 return NamePolicy::GetIdStatic();
1027 return GetIdStatic();
1052 return std::make_shared<MockLayerSupport>();
1073 class TestBackendAssignment :
public LayerVisitorBase<VisitorNoThrowPolicy>
1079 auto inputLayer = PolymorphicDowncast<const InputLayer*>(layer);
1080 BOOST_TEST((inputLayer->GetBackendId() ==
"MockBackend"));
1086 auto outputLayer = PolymorphicDowncast<const OutputLayer*>(layer);
1087 BOOST_TEST((outputLayer->GetBackendId() ==
"MockBackend"));
1092 const char* name =
nullptr)
override 1095 auto activation = PolymorphicDowncast<const ActivationLayer*>(layer);
1096 BOOST_TEST((activation->GetBackendId() ==
"CustomBackend"));
1120 backendRegistry.Register(
"MockBackend", []() {
return std::make_unique<MockBackend<MockPolicy>>(); });
1122 backendRegistry.Register(
"CustomBackend", []() {
return std::make_unique<MockBackend<CustomPolicy>>(); });
1129 std::unique_ptr<Graph> graph = std::make_unique<Graph>();
1130 auto input = graph->AddLayer<
InputLayer>(0,
"input");
1132 auto output = graph->AddLayer<
OutputLayer>(0,
"output");
1134 BackendId customBackendId(
"CustomBackend");
1145 std::vector<BackendId> prefs{
"MockBackend",
"CustomBackend" };
1147 BackendIdSet availableBackends = {
"CustomBackend",
"MockBackend" };
1163 BOOST_TEST(res.
IsOk());
1165 TestBackendAssignment visitor;
1166 for (
auto it = firstLayer; it != lastLayer; ++it)
1168 (*it)->Accept(visitor);
1175 using namespace armnn;
1183 const unsigned int inputDimensionSizes[] = { 1, 4, 4, 3 };
1184 const unsigned int weightsDimensionSizes[] = { 1, 2, 2, 3 };
1185 const unsigned int outputDimensionSizes[] = { 1, 3, 3, 1 };
1186 const unsigned int outputChannelSize[] = { outputDimensionSizes[3] };
1191 std::vector<float> weightsVector = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
1194 std::vector<float> betaVector = { 0.1f };
1195 std::vector<float> gammaVector = { 0.5f };
1196 std::vector<float> meanVector = { 0 };
1197 std::vector<float> varianceVector = { 1 };
1214 conv->m_Weight = std::make_unique<ScopedTensorHandle>(weights);
1215 batchNorm->m_Beta = std::make_unique<ScopedTensorHandle>(beta);
1216 batchNorm->m_Gamma = std::make_unique<ScopedTensorHandle>(gamma);
1217 batchNorm->m_Mean = std::make_unique<ScopedTensorHandle>(mean);
1218 batchNorm->m_Variance = std::make_unique<ScopedTensorHandle>(variance);
1219 if (convolution2dDescriptor.m_BiasEnabled)
1221 std::vector<float> biasVector = { 11 };
1223 conv->m_Bias = std::make_unique<ScopedTensorHandle>(bias);
1233 &IsLayerOfType<InputLayer>,
1234 &IsLayerOfType<Convolution2dLayer>,
1235 &IsLayerOfType<BatchNormalizationLayer>,
1236 &IsLayerOfType<OutputLayer>));
1241 auto checkFusedConv2d = [](
const armnn::Layer*
const layer) ->
bool {
1242 return IsLayerOfType<armnn::Convolution2dLayer>(layer) &&
1243 (layer->
GetNameStr() ==
"fused-batchNorm-into-convolution");
1248 &IsLayerOfType<InputLayer>,
1250 &IsLayerOfType<OutputLayer>));
1275 &IsLayerOfType<armnn::InputLayer>,
1276 &IsLayerOfType<armnn::Convolution2dLayer>,
1277 &IsLayerOfType<armnn::BatchNormalizationLayer>,
1278 &IsLayerOfType<armnn::OutputLayer>,
1279 &IsLayerOfType<armnn::OutputLayer>));
1285 &IsLayerOfType<armnn::InputLayer>,
1286 &IsLayerOfType<armnn::Convolution2dLayer>,
1287 &IsLayerOfType<armnn::BatchNormalizationLayer>,
1288 &IsLayerOfType<armnn::OutputLayer>,
1289 &IsLayerOfType<armnn::OutputLayer>));
BOOST_AUTO_TEST_SUITE(TensorflowLiteParser)
std::shared_ptr< ConstTensorHandle > m_ForgetGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
Iterator begin()
Returns iterator pointing to the beginning of the list. Lowercase for range-based for loops...
std::shared_ptr< ConstTensorHandle > m_OutputGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
bool m_BiasEnabled
Enable/disable bias.
bool m_ProjectionEnabled
Enable/disable the projection layer.
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
OptimizationResult AssignBackends(OptimizedNetworkImpl *optNetObjPtr, BackendSettings &backendSettings, Graph::Iterator &firstLayer, Graph::Iterator &lastLayer, Optional< std::vector< std::string > &> errMessages)
static IRuntimePtr Create(const CreationOptions &options)
LstmBasicParameters m_BasicParameters
This layer represents a batch normalization operation.
std::unique_ptr< IWorkloadFactory > IWorkloadFactoryPtr
Interface for a layer that is connectable to other layers via InputSlots and OutputSlots.
uint32_t m_PadBottom
Padding bottom value in the height dimension.
std::vector< ConvertFp32ToFp16Layer * > InsertConvertFp32ToFp16LayersAfter(Graph &graph, Layer &layer)
bool m_BiasEnabled
Enable/disable bias.
std::shared_ptr< ConstTensorHandle > m_CellToForgetWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
std::vector< OptimizationPtr > Optimizations
const Parameters & GetParameters() const
std::vector< ConvertFp16ToFp32Layer * > InsertConvertFp16ToFp32LayersBefore(Graph &graph, Layer &layer, bool expectCorrectInputType)
CPU Execution: Reference C++ kernels.
uint32_t m_PadLeft
Padding left value in the width dimension.
OptimizeForExclusiveConnection< PadLayer, Convolution2dLayer, pad_fold::FoldPadIntoConvolution2dImpl > FoldPadIntoConvolution2d
Optimizer::Optimizations MakeOptimizations(Args &&... args)
float m_ClippingThresProj
Clipping threshold value for the projection.
std::unordered_set< BackendId > BackendIdSet
void BackendSelectionHint(Optional< BackendId > backend) final
Provide a hint for the optimizer as to which backend to prefer for this layer.
float m_PadValue
Optional value to use for padding, defaults to 0.
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
This layer represents a depthwise convolution 2d operation.
LayerT * AddLayer(Args &&... args)
Adds a new layer, of type LayerType, to the graph constructed with the arguments passed.
uint32_t m_PoolWidth
Pooling width value.
ConstIterator cbegin() const
Returns const iterator pointing to the beginning of the list. Lowercase for range-based for loops...
A Convolution2dDescriptor for the Convolution2dLayer.
void CreateResizeBilinearGraph(Graph &graph, const unsigned int *inputShape, const unsigned int *outputShape, DataLayout dataLayout=DataLayout::NCHW)
int Connect(InputSlot &destination)
ResizeMethod m_Method
The Interpolation method to use (Bilinear, NearestNeighbor).
static void Pass(Graph &graph, const Optimizations &optimizations)
std::unique_ptr< IRuntime, void(*)(IRuntime *runtime)> IRuntimePtr
The padding fields don't count and are ignored.
PaddingMethod m_PaddingMethod
The padding method to be used. (Exclude, IgnoreValue).
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
OptimizeForExclusiveConnection< Convolution2dLayer, BatchNormalizationLayer, FuseBatchNorm< Convolution2dLayer, armnn::DataType::Float32 > > FuseBatchNormIntoConvolution2DFloat32
std::shared_ptr< ConstTensorHandle > m_Weight
A unique pointer to store Weight values.
This layer represents an activation operation with the specified activation function.
BackendRegistry & BackendRegistryInstance()
uint32_t m_PadTop
Padding top value in the height dimension.
std::vector< std::pair< LayerBindingId, class ConstTensor > > InputTensors
std::shared_ptr< ConstTensorHandle > m_ProjectionWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
This layer represents a detection postprocess operator.
void CreatePooling2dGraph(Graph &graph, const unsigned int *inputShape, const unsigned int *outputShape, DataLayout dataLayout=DataLayout::NCHW)
Copyright (c) 2021 ARM Limited and Contributors.
std::shared_ptr< ConstTensorHandle > m_InputToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
std::unique_ptr< IMemoryManager > IMemoryManagerUniquePtr
This layer represents a pad operation.
This layer represents a LSTM operation.
void IgnoreUnused(Ts &&...)
LayerList::const_iterator Iterator
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
int LayerBindingId
Type of identifiers for bindable layers (inputs, outputs).
virtual void SetTensorInfo(const TensorInfo &tensorInfo)=0
A ResizeDescriptor for the ResizeLayer.
std::shared_ptr< ConstTensorHandle > m_InputGateBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
A tensor defined by a TensorInfo (shape and data type) and a mutable backing store.
bool IsInputSupported(const BackendId &backend, const TensorInfo &input, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
std::shared_ptr< ConstTensorHandle > m_CellToOutputWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
The SubgraphView class represents a subgraph of a Graph.
uint32_t m_PoolHeight
Pooling height value.
Constant weights can be accessed through the descriptors, On the other hand, non-const weights can be...
uint32_t m_MaxDetections
Maximum numbers of detections.
A PadDescriptor for the PadLayer.
const InputSlot & GetInputSlot(unsigned int index) const override
Get a const input slot handle by slot index.
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
std::shared_ptr< ConstTensorHandle > m_RecurrentToCellWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
uint32_t m_StrideX
Stride value when proceeding through input for the width dimension.
A layer user-provided data can be bound to (e.g. inputs, outputs).
std::shared_ptr< ConstTensorHandle > m_CellBias
A unique pointer to represent 1D weights tensor with dimensions [num_units].
This layer represents a Gather operator.
An LstmDescriptor for the LstmLayer.
uint32_t m_PadRight
Padding right value in the width dimension.
IOptimizedNetworkPtr Optimize(const INetwork &network, const std::vector< BackendId > &backendPreferences, const IDeviceSpec &deviceSpec, const OptimizerOptions &options=OptimizerOptions(), Optional< std::vector< std::string > &> messages=EmptyOptional())
Create an optimized version of the network.
#define ARMNN_ASSERT_MSG(COND, MSG)
void CreateGatherGraph(Graph &graph, const armnn::TensorInfo ¶msInfo, const armnn::TensorInfo &indicesInfo, const armnn::TensorInfo &outputInfo)
std::shared_ptr< IMemoryManager > IMemoryManagerSharedPtr
bool IsOutputSupported(const BackendId &backend, const TensorInfo &output, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
DataType GetDataType() const
A tensor defined by a TensorInfo (shape and data type) and an immutable backing store.
std::vector< std::pair< LayerBindingId, class Tensor > > OutputTensors
const std::string & GetNameStr() const
LayerType GetType() const override
Returns the armnn::LayerType of this layer.
uint32_t m_TargetWidth
Target width value.
A GatherDescriptor for the GatherLayer.
std::shared_ptr< ConstTensorHandle > m_RecurrentToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
bool m_PeepholeEnabled
Enable/disable peephole.
std::unique_ptr< IOptimizedNetwork, void(*)(IOptimizedNetwork *network)> IOptimizedNetworkPtr
This layer represents a memory copy operation.
#define ARMNN_ASSERT(COND)
std::shared_ptr< ConstTensorHandle > m_RecurrentToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
BOOST_AUTO_TEST_CASE(CheckConvolution2dLayer)
std::shared_ptr< ConstTensorHandle > m_InputToInputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
bool IsActivationSupported(const BackendId &backend, const TensorInfo &input, const TensorInfo &output, const ActivationDescriptor &descriptor, char *reasonIfUnsupported=nullptr, size_t reasonIfUnsupportedMaxLength=1024)
Deprecated in favor of IBackend and ILayerSupport interfaces.
An ActivationDescriptor for the ActivationLayer.
This layer represents a floor operation.
std::shared_ptr< ConstTensorHandle > m_ProjectionBias
A unique pointer to represent 1D weights tensor with dimensions [output_size].
uint32_t m_TargetHeight
Target height value.
uint32_t m_ActivationFunc
The activation function to use.
Visitor base class with empty implementations.
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
This layer represents a pooling 2d operation.
float m_ClippingThresCell
Clipping threshold value for the cell state.
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
This layer represents an addition operation.
LstmOptPeepholeParameters m_PeepholeParameters
void SetTensorInfo(const TensorInfo &tensorInfo)
Sets the TensorInfo used by this output handler.
std::shared_ptr< ILayerSupport > ILayerSupportSharedPtr
LstmOptProjectionParameters m_ProjectionParameters
BOOST_AUTO_TEST_SUITE_END()
bool m_CifgEnabled
Enable/disable cifg (coupled input & forget gate).
EmptyOptional is used to initialize the Optional class in case we want to have default value for an O...
std::shared_ptr< ConstTensorHandle > m_InputToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
PoolingAlgorithm m_PoolType
The pooling algorithm to use (Max. Average, L2).
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
std::shared_ptr< ConstTensorHandle > m_RecurrentToForgetWeights
A unique pointer to represent 2D weights tensor with dimensions [output_size, num_units].
The padding fields count, but are ignored.
std::shared_ptr< ConstTensorHandle > m_Weight
A unique pointer to store Weight values.
bool IsCapabilitySupported(const armnn::BackendId &backend, armnn::BackendCapability capability)
Convenience function to check a capability on a backend.
const OutputHandler & GetOutputHandler(unsigned int i=0) const
OptimizeForExclusiveConnection< PadLayer, Pooling2dLayer, pad_fold::FoldPadIntoPooling2dImpl > FoldPadIntoPooling2d
Iterator end()
Returns iterator pointing to the end of the list. Lowercase for range-based for loops.
bool CheckSequence(const armnn::Graph::ConstIterator first, const armnn::Graph::ConstIterator last)
void CreateConvolution2dGraph(Graph &graph, const unsigned int *inputShape, const unsigned int *weightsShape, const unsigned int *outputShape, DataLayout dataLayout=DataLayout::NCHW)
void SetTensorInfo(const TensorInfo &tensorInfo) override
virtual const IInputSlot & GetInputSlot(unsigned int index) const =0
Get a const input slot handle by slot index.
armnn::TensorInfo scoresInfo({ 1, 6, 3 }, armnn::DataType::Float32)
DataType GetDataType() const
const OutputSlot & GetOutputSlot(unsigned int index=0) const override
Get the const output slot handle by slot index.
virtual const IOutputSlot & GetOutputSlot(unsigned int index) const =0
Get the const output slot handle by slot index.
LstmOptCifgParameters m_CifgParameters
ConstIterator cend() const
Returns const iterator pointing to the end of the list. Lowercase for range-based for loops...
This layer represents a convolution 2d operation.
void Connect(armnn::IConnectableLayer *from, armnn::IConnectableLayer *to, const armnn::TensorInfo &tensorInfo, unsigned int fromIndex, unsigned int toIndex)
std::unique_ptr< INetwork, void(*)(INetwork *network)> INetworkPtr
virtual int Connect(IInputSlot &destination)=0
A Pooling2dDescriptor for the Pooling2dLayer.
std::shared_ptr< ConstTensorHandle > m_CellToInputWeights
A unique pointer to represent 1D weights tensor with dimensions [num_units].
size_t GetNumLayers() const
DataLayout m_DataLayout
The data layout to be used (NCHW, NHWC).
std::shared_ptr< ConstTensorHandle > m_Anchors
A unique pointer to store Anchor values.
void CreateDepthwiseConvolution2dGraph(Graph &graph, const unsigned int *inputShape, const unsigned int *weightsShape, const unsigned int *outputShape, DataLayout dataLayout=DataLayout::NCHW)
const TensorInfo & GetTensorInfo() const override
static INetworkPtr Create(NetworkOptions networkOptions={})
ActivationFunction m_Function
The activation function to use (Sigmoid, TanH, Linear, ReLu, BoundedReLu, SoftReLu, LeakyReLu, Abs, Sqrt, Square, Elu).
uint32_t m_StrideY
Stride value when proceeding through input for the height dimension.
A DepthwiseConvolution2dDescriptor for the DepthwiseConvolution2dLayer.
A BatchNormalizationDescriptor for the BatchNormalizationLayer.
This layer represents a resize operation.
std::shared_ptr< ConstTensorHandle > m_InputToOutputWeights
A unique pointer to represent 2D weights tensor with dimensions [input_size, num_units].
std::vector< float > anchors({ 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 0.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 10.5f, 1.0f, 1.0f, 0.5f, 100.5f, 1.0f, 1.0f })
std::unique_ptr< IBackendContext > IBackendContextPtr