//
#pragma once
+#include <armnn/Deprecated.hpp>
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/Optional.hpp>
const BatchToSpaceNdDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+ virtual bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+
virtual bool IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+ ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
virtual bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
const OriginsDescriptor& descriptor,
const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
const char* name = nullptr) = 0;
+ /// Function that a concat layer should call back to when its Accept(ILayerVisitor&) function is invoked.
+ /// @param layer - pointer to the layer which is calling back to this visit function.
+ /// @param mergerDescriptor - WindowsDescriptor to configure the concatenation process. Number of Views must be
+ /// equal to the number of inputs, and their order must match - e.g. first view
+ /// corresponds to the first input, second view to the second input, etc....
+ /// @param name - Optional name for the layer.
+ virtual void VisitConcatLayer(const IConnectableLayer* layer,
+ const OriginsDescriptor& mergerDescriptor,
+ const char* name = nullptr)
+ {
+ // default implementation to ease transition while MergerLayer is being deprecated
+ VisitMergerLayer(layer, mergerDescriptor, name);
+ }
+
/// Function a layer with no inputs and a single output, which always corresponds to
/// the passed in constant tensor should call back to when its Accept(ILayerVisitor&) function is invoked.
/// @param layer - pointer to the layer which is calling back to this visit function.
/// the number of inputs, and their order must match - e.g. first view corresponds to
/// the first input, second view to the second input, etc....
/// @param name - Optional name for the layer.
+ // NOTE: this method will be deprecated and replaced by VisitConcatLayer
virtual void VisitMergerLayer(const IConnectableLayer* layer,
const OriginsDescriptor& mergerDescriptor,
const char* name = nullptr) = 0;
//
#pragma once
+#include <armnn/Deprecated.hpp>
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/ILayerVisitor.hpp>
#include <armnn/NetworkFwd.hpp>
/// @return - Interface for configuring the layer.
virtual IConnectableLayer* AddInputLayer(LayerBindingId id, const char* name = nullptr) = 0;
+ /// Adds a concatenation layer to the network.
+ /// @param mergerDescriptor - WindowsDescriptor to configure the concatenation process. Number of Views must
+ /// be equal to the number of inputs, and their order must match - e.g. first view
+ /// corresponds to the first input, second view to the second input, etc....
+ /// @param name - Optional name for the layer.
+ /// @return - Interface for configuring the layer.
+ virtual IConnectableLayer* AddConcatLayer(const OriginsDescriptor& mergerDescriptor,
+ const char* name = nullptr) = 0;
+
/// Adds a 2D convolution layer to the network.
/// @param convolution2dDescriptor - Description of the 2D convolution layer.
/// @param weights - Tensor for the weights data.
/// the first input, second view to the second input, etc....
/// @param name - Optional name for the layer.
/// @return - Interface for configuring the layer.
+ ARMNN_DEPRECATED_MSG("Use AddConcatLayer instead")
virtual IConnectableLayer* AddMergerLayer(const OriginsDescriptor& mergerDescriptor,
const char* name = nullptr) = 0;
//
#pragma once
+#include <armnn/Deprecated.hpp>
#include <armnn/DescriptorsFwd.hpp>
#include <armnn/Optional.hpp>
#include <armnn/Tensor.hpp>
size_t reasonIfUnsupportedMaxLength = 1024);
/// Deprecated in favor of IBackend and ILayerSupport interfaces
+bool IsConcatSupported(const BackendId& backend,
+ const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ char* reasonIfUnsupported = nullptr,
+ size_t reasonIfUnsupportedMaxLength = 1024);
+
+/// Deprecated in favor of IBackend and ILayerSupport interfaces
bool IsConstantSupported(const BackendId& backend,
const TensorInfo& output,
char* reasonIfUnsupported = nullptr,
size_t reasonIfUnsupportedMaxLength = 1024);
/// Deprecated in favor of IBackend and ILayerSupport interfaces
+ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const BackendId& backend,
const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
LayerBindingId,
const char*) override { DefaultPolicy::Apply(); }
+ void VisitConcatLayer(const IConnectableLayer*,
+ const OriginsDescriptor&,
+ const char*) override { DefaultPolicy::Apply(); }
+
void VisitConvolution2dLayer(const IConnectableLayer*,
const Convolution2dDescriptor&,
const ConstTensor&,
descriptor);
}
+bool IsConcatSupported(const BackendId& backend,
+ std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ char* reasonIfUnsupported,
+ size_t reasonIfUnsupportedMaxLength)
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return IsMergerSupported(backend, inputs, output, descriptor, reasonIfUnsupported, reasonIfUnsupportedMaxLength);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
bool IsConstantSupported(const BackendId& backend,
const TensorInfo& output,
char* reasonIfUnsupported,
FORWARD_LAYER_SUPPORT_FUNC(backend, IsMergeSupported, input0, input1, output);
}
+ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const BackendId& backend,
std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
size_t reasonIfUnsupportedMaxLength)
{
BOOST_ASSERT(inputs.size() > 0);
+
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
FORWARD_LAYER_SUPPORT_FUNC(backend, IsMergerSupported, inputs, output, descriptor);
+ ARMNN_NO_DEPRECATE_WARN_END
}
bool IsMinimumSupported(const BackendId& backend,
return AddFullyConnectedLayerImpl(fullyConnectedDescriptor, weights, optionalBiases, name);
}
+IConnectableLayer* Network::AddConcatLayer(const OriginsDescriptor& mergerDescriptor,
+ const char* name)
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return AddMergerLayer(mergerDescriptor, name);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
IConnectableLayer* Network::AddConvolution2dLayerImpl(const Convolution2dDescriptor& convolution2dDescriptor,
const ConstTensor& weights,
const Optional<ConstTensor>& biases,
}
IConnectableLayer* Network::AddMergerLayer(const OriginsDescriptor& mergerDescriptor,
- const char* name)
+ const char* name)
{
return m_Graph->AddLayer<MergerLayer>(mergerDescriptor, name);
}
IConnectableLayer* AddBatchToSpaceNdLayer(const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
const char* name = nullptr) override;
+ IConnectableLayer* AddConcatLayer(const OriginsDescriptor& mergerDescriptor,
+ const char* name = nullptr) override;
+
IConnectableLayer* AddConvolution2dLayer(const Convolution2dDescriptor& convolution2dDescriptor,
const ConstTensor& weights,
const Optional<ConstTensor>& biases,
IConnectableLayer* AddSplitterLayer(const ViewsDescriptor& splitterDescriptor,
const char* name = nullptr) override;
+ ARMNN_DEPRECATED_MSG("Use AddConcatLayer instead")
IConnectableLayer* AddMergerLayer(const OriginsDescriptor& mergerDescriptor,
- const char* name = nullptr) override;
+ const char* name = nullptr) override;
IConnectableLayer* AddAdditionLayer(const char* name = nullptr) override;
const OriginsDescriptor& mergerDescriptor,
const char* name)
{
- IConnectableLayer* newLayer = m_QuantizedNetwork->AddMergerLayer(mergerDescriptor, name);
+ IConnectableLayer* newLayer = m_QuantizedNetwork->AddConcatLayer(mergerDescriptor, name);
RecordLayer(layer, newLayer);
SetQuantizedInputConnections(layer, newLayer);
}
// Adds a merger layer.
armnn::OriginsDescriptor mergerDesc(2, 4);
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
armnn::IConnectableLayer* mergerLayer = net.AddMergerLayer(mergerDesc, "merger layer");
+ ARMNN_NO_DEPRECATE_WARN_END
BOOST_TEST(mergerLayer);
softmaxLayer1->GetOutputSlot(0).Connect(mergerLayer->GetInputSlot(0));
IConnectableLayer* input2 = network->AddInputLayer(2);
OriginsDescriptor descriptor(3, 1);
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
IConnectableLayer* merger = network->AddMergerLayer(descriptor);
+ ARMNN_NO_DEPRECATE_WARN_END
IConnectableLayer* output0 = network->AddOutputLayer(3);
TestMergerLayerVisitor visitor(descriptor, layerName);
Network net;
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
IConnectableLayer *const layer = net.AddMergerLayer(descriptor, layerName);
+ ARMNN_NO_DEPRECATE_WARN_END
layer->Accept(visitor);
}
TestMergerLayerVisitor visitor(descriptor);
Network net;
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
IConnectableLayer *const layer = net.AddMergerLayer(descriptor);
+ ARMNN_NO_DEPRECATE_WARN_END
layer->Accept(visitor);
}
outputShape.set_dim(1, mergeDimSizes[1]);
// Finally add the merge layer
- IConnectableLayer* mergerLayer = m_Network->AddMergerLayer(mergeDesc, layerParam.name().c_str());
+ IConnectableLayer* mergerLayer = m_Network->AddConcatLayer(mergeDesc, layerParam.name().c_str());
if (!mergerLayer)
{
}
mergeDimSizes[concatDim] = mergeDim;
- armnn::IConnectableLayer* concatlayer = m_Network->AddMergerLayer(concatDescriptor, layerParam.name().c_str());
+ armnn::IConnectableLayer* concatlayer = m_Network->AddConcatLayer(concatDescriptor, layerParam.name().c_str());
for (unsigned int i = 0; i < numInputs; ++i)
{
armnn::IOutputSlot& outputSlot = GetArmnnOutputSlotForCaffeTop(layerParam.bottom(boost::numeric_cast<int>(i)));
m_ParserFunctions[Layer_MeanLayer] = &Deserializer::ParseMean;
m_ParserFunctions[Layer_MinimumLayer] = &Deserializer::ParseMinimum;
m_ParserFunctions[Layer_MergeLayer] = &Deserializer::ParseMerge;
- m_ParserFunctions[Layer_MergerLayer] = &Deserializer::ParseMerger;
+ m_ParserFunctions[Layer_MergerLayer] = &Deserializer::ParseConcat;
m_ParserFunctions[Layer_MultiplicationLayer] = &Deserializer::ParseMultiplication;
m_ParserFunctions[Layer_NormalizationLayer] = &Deserializer::ParseNormalization;
m_ParserFunctions[Layer_PadLayer] = &Deserializer::ParsePad;
RegisterOutputSlots(graph, layerIndex, layer);
}
-void Deserializer::ParseMerger(GraphPtr graph, unsigned int layerIndex)
+void Deserializer::ParseConcat(GraphPtr graph, unsigned int layerIndex)
{
CHECK_LAYERS(graph, 0, layerIndex);
CHECK_LOCATION();
}
descriptor.SetConcatAxis(mergerDescriptor->concatAxis());
- IConnectableLayer* layer = m_Network->AddMergerLayer(descriptor, layerName.c_str());
+ IConnectableLayer* layer = m_Network->AddConcatLayer(descriptor, layerName.c_str());
armnn::TensorInfo outputTensorInfo = ToTensorInfo(outputs[0]);
layer->GetOutputSlot(0).SetTensorInfo(outputTensorInfo);
void ParseAdd(GraphPtr graph, unsigned int layerIndex);
void ParseBatchToSpaceNd(GraphPtr graph, unsigned int layerIndex);
void ParseBatchNormalization(GraphPtr graph, unsigned int layerIndex);
+ void ParseConcat(GraphPtr graph, unsigned int layerIndex);
void ParseConstant(GraphPtr graph, unsigned int layerIndex);
void ParseConvolution2d(GraphPtr graph, unsigned int layerIndex);
void ParseDepthwiseConvolution2d(GraphPtr graph, unsigned int layerIndex);
void ParseMean(GraphPtr graph, unsigned int layerIndex);
void ParseMinimum(GraphPtr graph, unsigned int layerIndex);
void ParseMerge(GraphPtr graph, unsigned int layerIndex);
- void ParseMerger(GraphPtr graph, unsigned int layerIndex);
void ParseMultiplication(GraphPtr graph, unsigned int layerIndex);
void ParseNormalization(GraphPtr graph, unsigned int layerIndex);
void ParseLstm(GraphPtr graph, unsigned int layerIndex);
* Addition
* BatchToSpaceNd
* BatchNormalization
+* Concat
* Constant
* Convolution2d
* DepthwiseConvolution2d
* Maximum
* Mean
* Merge
-* Merger
* Minimum
* Multiplication
* Normalization
armnn::INetworkPtr network = armnn::INetwork::Create();
armnn::IConnectableLayer* const inputLayerOne = network->AddInputLayer(0);
armnn::IConnectableLayer* const inputLayerTwo = network->AddInputLayer(1);
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
armnn::IConnectableLayer* const mergerLayer = network->AddMergerLayer(descriptor, layerName.c_str());
+ ARMNN_NO_DEPRECATE_WARN_END
armnn::IConnectableLayer* const outputLayer = network->AddOutputLayer(0);
inputLayerOne->GetOutputSlot(0).Connect(mergerLayer->GetInputSlot(0));
}
auto layerName = boost::str(boost::format("Concatenation:%1%:%2%") % subgraphIndex % operatorIndex);
- IConnectableLayer* layer = m_Network->AddMergerLayer(concatDescriptor, layerName.c_str());
+ IConnectableLayer* layer = m_Network->AddConcatLayer(concatDescriptor, layerName.c_str());
BOOST_ASSERT(layer != nullptr);
// Update the output shape
mergeDims[concatDim] = mergeDim;
- armnn::IConnectableLayer *layer = m_Network->AddMergerLayer(concatDescriptor, nodeDef.name().c_str());
+ armnn::IConnectableLayer *layer = m_Network->AddConcatLayer(concatDescriptor, nodeDef.name().c_str());
layer->GetOutputSlot(0).SetTensorInfo(armnn::TensorInfo(mergeDims, DataType::Float32));
return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
}
+bool LayerSupportBase::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
bool LayerSupportBase::IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
const BatchToSpaceNdDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
const OriginsDescriptor& descriptor,
const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
result = layerSupportObject->IsMergerSupported(inputPtrs, output, cLayer->GetParameters(), reason);
+ ARMNN_NO_DEPRECATE_WARN_END
break;
}
case LayerType::Multiplication:
descriptor = CreateMergerDescriptorForConcatenation(inputShapes.begin(),
inputShapes.end(),
concatAxis);
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
IConnectableLayer* merger = net->AddMergerLayer(descriptor, "merger");
+ ARMNN_NO_DEPRECATE_WARN_END
for (unsigned int i = 0; i < inputShapes.size(); ++i)
{
descriptor);
}
+bool ClLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
bool ClLayerSupport::IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
const BatchToSpaceNdDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
const OriginsDescriptor& descriptor,
descriptor);
}
+bool NeonLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
bool NeonLayerSupport::IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
const BatchNormalizationDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
const OriginsDescriptor& descriptor,
&TrueFunc<>));
}
+bool RefLayerSupport::IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ ARMNN_NO_DEPRECATE_WARN_BEGIN
+ return IsMergerSupported(inputs, output, descriptor, reasonIfUnsupported);
+ ARMNN_NO_DEPRECATE_WARN_END
+}
+
bool RefLayerSupport::IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
const BatchToSpaceNdDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsConcatSupported(const std::vector<const TensorInfo*> inputs,
+ const TensorInfo& output,
+ const OriginsDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsConstantSupported(const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
const MeanDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ ARMNN_DEPRECATED_MSG("Use IsConcatSupported instead")
bool IsMergerSupported(const std::vector<const TensorInfo*> inputs,
const TensorInfo& output,
const OriginsDescriptor& descriptor,