src/armnn/layers/AbsLayer.cpp \
src/armnn/layers/ActivationLayer.cpp \
src/armnn/layers/AdditionLayer.cpp \
+ src/armnn/layers/ArgMinMaxLayer.cpp \
src/armnn/layers/BatchNormalizationLayer.cpp \
src/armnn/layers/BatchToSpaceNdLayer.cpp \
src/armnn/layers/ConcatLayer.cpp \
src/armnn/layers/ActivationLayer.cpp
src/armnn/layers/AdditionLayer.hpp
src/armnn/layers/AdditionLayer.cpp
+ src/armnn/layers/ArgMinMaxLayer.hpp
+ src/armnn/layers/ArgMinMaxLayer.cpp
src/armnn/layers/BatchNormalizationLayer.hpp
src/armnn/layers/BatchNormalizationLayer.cpp
src/armnn/layers/BatchToSpaceNdLayer.hpp
float m_B;
};
+/// An ArgMinMaxDescriptor for ArgMinMaxLayer
+struct ArgMinMaxDescriptor
+{
+ ArgMinMaxDescriptor()
+ : m_Axis(-1) {}
+
+ int m_Axis;
+};
+
/// A PermuteDescriptor for the PermuteLayer.
struct PermuteDescriptor
{
namespace armnn
{
struct ActivationDescriptor;
+struct ArgMinMaxDescriptor;
struct BatchNormalizationDescriptor;
struct BatchToSpaceNdDescriptor;
struct Convolution2dDescriptor;
#include <functional>
#include <memory>
#include <vector>
+#include "ArmNN.hpp"
namespace armnn
{
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+ virtual bool IsArgMinMaxSupported(const TensorInfo& input,
+ const TensorInfo& output,
+ const ArgMinMaxDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
+
virtual bool IsBatchNormalizationSupported(const TensorInfo& input,
const TensorInfo& output,
const TensorInfo& mean,
virtual void VisitAdditionLayer(const IConnectableLayer* layer,
const char* name = nullptr) = 0;
+ /// Function that an arg min max 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 argMinMaxDescriptor - ArgMinMaxDescriptor to configure the activation.
+ /// @param name - Optional name for the layer.
+ virtual void VisitArgMinMaxLayer(const IConnectableLayer* layer,
+ const ArgMinMaxDescriptor& argMinMaxDescriptor,
+ const char* name = nullptr) = 0;
+
/// Function that a batch normalization 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.
/// @return - Interface for configuring the layer.
virtual IConnectableLayer* AddInputLayer(LayerBindingId id, const char* name = nullptr) = 0;
+ /// Adds an ArgMinMax layer to the network.
+ /// @param desc - Parameters for the L2 normalization operation.
+ /// @param name - Optional name for the layer.
+ /// @return - Interface for configuring the layer.
+ virtual IConnectableLayer* AddArgMinMaxLayer(const ArgMinMaxDescriptor& desc,
+ const char* name = nullptr) = 0;
+
/// Adds a concatenation layer to the network.
/// @param concatDescriptor - ConcatDescriptor (synonym for OriginsDescriptor) to configure the concatenation
/// process. Number of Views must be equal to the number of inputs, and their order
void VisitAdditionLayer(const IConnectableLayer*,
const char*) override { DefaultPolicy::Apply(__func__); }
+ void VisitArgMinMaxLayer(const IConnectableLayer*,
+ const ArgMinMaxDescriptor&,
+ const char*) override { DefaultPolicy::Apply(__func__); }
+
void VisitBatchNormalizationLayer(const IConnectableLayer*,
const BatchNormalizationDescriptor&,
const ConstTensor&,
Abs = FirstLayer,
Activation,
Addition,
+ ArgMinMax,
BatchNormalization,
BatchToSpaceNd,
Concat,
FORWARD_LAYER_SUPPORT_FUNC(backend, IsAdditionSupported, input0, input1, output);
}
+bool IsArgMinMaxSupported(const BackendId& backend,
+ const TensorInfo& input,
+ const TensorInfo& output,
+ const ArgMinMaxDescriptor& descriptor,
+ char* reasonIfUnsupported,
+ size_t reasonIfUnsupportedMaxLength)
+{
+ FORWARD_LAYER_SUPPORT_FUNC(backend, IsArgMinMaxSupported, input, output, descriptor);
+}
+
bool IsBatchNormalizationSupported(const BackendId& backend,
const TensorInfo& input,
const TensorInfo& output,
#include "layers/AbsLayer.hpp"
#include "layers/ActivationLayer.hpp"
#include "layers/AdditionLayer.hpp"
+#include "layers/ArgMinMaxLayer.hpp"
#include "layers/BatchNormalizationLayer.hpp"
#include "layers/BatchToSpaceNdLayer.hpp"
#include "layers/ConcatLayer.hpp"
DECLARE_LAYER(Abs)
DECLARE_LAYER(Activation)
DECLARE_LAYER(Addition)
+DECLARE_LAYER(ArgMinMax)
DECLARE_LAYER(BatchNormalization)
DECLARE_LAYER(BatchToSpaceNd)
DECLARE_LAYER(Concat)
return m_Graph->AddLayer<ActivationLayer>(activationDescriptor, name);
}
+IConnectableLayer* Network::AddArgMinMaxLayer(const ArgMinMaxDescriptor& argMinMaxDescriptor,
+ const char* name)
+{
+ return m_Graph->AddLayer<ArgMinMaxLayer>(argMinMaxDescriptor, name);
+}
+
IConnectableLayer* Network::AddNormalizationLayer(const NormalizationDescriptor&
normalizationDescriptor,
const char* name)
IConnectableLayer* AddInputLayer(LayerBindingId id, const char* name=nullptr) override;
+ IConnectableLayer* AddArgMinMaxLayer(const ArgMinMaxDescriptor& desc,
+ const char* name = nullptr) override;
+
IConnectableLayer* AddBatchToSpaceNdLayer(const BatchToSpaceNdDescriptor& batchToSpaceNdDescriptor,
const char* name = nullptr) override;
--- /dev/null
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+#include "ArgMinMaxLayer.hpp"
+
+#include "LayerCloneBase.hpp"
+
+#include <armnn/TypesUtils.hpp>
+#include <backendsCommon/WorkloadData.hpp>
+#include <backendsCommon/WorkloadFactory.hpp>
+
+namespace armnn
+{
+
+ArgMinMaxLayer::ArgMinMaxLayer(const ArgMinMaxDescriptor& param, const char* name)
+ : LayerWithParameters(1, 1, LayerType::ArgMinMax, param, name)
+{
+}
+
+std::unique_ptr<IWorkload> ArgMinMaxLayer::CreateWorkload(const Graph& graph,
+ const IWorkloadFactory& factory) const
+{
+ ArgMinMaxQueueDescriptor descriptor;
+ return factory.CreateArgMinMax(descriptor, PrepInfoAndDesc(descriptor, graph));
+}
+
+ArgMinMaxLayer* ArgMinMaxLayer::Clone(Graph& graph) const
+{
+ return CloneBase<ArgMinMaxLayer>(graph, m_Param, GetName());
+}
+
+void ArgMinMaxLayer::ValidateTensorShapesFromInputs()
+{
+ VerifyLayerConnections(1, CHECK_LOCATION());
+
+ auto inferredShapes = InferOutputShapes({ GetInputSlot(0).GetConnection()->GetTensorInfo().GetShape() });
+
+ BOOST_ASSERT(inferredShapes.size() == 1);
+
+ ConditionalThrowIfNotEqual<LayerValidationException>(
+ "ArgMinMaxLayer: TensorShape set on OutputSlot does not match the inferred shape.",
+ GetOutputSlot(0).GetTensorInfo().GetShape(),
+ inferredShapes[0]);
+}
+
+void ArgMinMaxLayer::Accept(ILayerVisitor& visitor) const
+{
+ visitor.VisitArgMinMaxLayer(this, GetParameters(), GetName());
+}
+
+} // namespace armnn
\ No newline at end of file
--- /dev/null
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include "LayerWithParameters.hpp"
+
+namespace armnn
+{
+
+/// This layer represents a ArgMinMax operation.
+class ArgMinMaxLayer : public LayerWithParameters<ArgMinMaxDescriptor>
+{
+public:
+ /// Makes a workload for the ArgMinMax type.
+ /// @param [in] graph The graph where this layer can be found.
+ /// @param [in] factory The workload factory which will create the workload.
+ /// @return A pointer to the created workload, or nullptr if not created.
+ virtual std::unique_ptr<IWorkload> CreateWorkload(const Graph& graph,
+ const IWorkloadFactory& factory) const override;
+
+ /// Creates a dynamically-allocated copy of this layer.
+ /// @param [in] graph The graph into which this layer is being cloned.
+ ArgMinMaxLayer* Clone(Graph& graph) const override;
+
+ /// Check if the input tensor shape(s)
+ /// will lead to a valid configuration of @ref ArgMinMaxLayer.
+ void ValidateTensorShapesFromInputs() override;
+
+ void Accept(ILayerVisitor& visitor) const override;
+
+protected:
+ /// Constructor to create a ArgMinMaxLayer.
+ /// @param [in] param ArgMinMaxDescriptor to configure the ArgMinMax operation.
+ /// @param [in] name Optional name for the layer.
+ ArgMinMaxLayer(const ArgMinMaxDescriptor& param, const char* name);
+
+ /// Default destructor
+ ~ArgMinMaxLayer() = default;
+};
+
+}
\ No newline at end of file
CreateAnyLayer(flatBufferAdditionLayer.o, serializer::Layer::Layer_AdditionLayer);
}
+// Build FlatBuffer for ArgMinMax Layer
+void SerializerVisitor::VisitArgMinMaxLayer(const armnn::IConnectableLayer *layer,
+ const armnn::ArgMinMaxDescriptor& descriptor,
+ const char *name)
+{
+ // This will be implemented in IVGCVSW-3724
+ throw UnimplementedException("SerializerVisitor::VisitArgMinMaxLayer is not implemented");
+}
+
// Build FlatBuffer for BatchToSpaceNd Layer
void SerializerVisitor::VisitBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
const armnn::BatchToSpaceNdDescriptor& descriptor,
void VisitAdditionLayer(const armnn::IConnectableLayer* layer,
const char* name = nullptr) override;
+ void VisitArgMinMaxLayer(const armnn::IConnectableLayer* layer,
+ const armnn::ArgMinMaxDescriptor& argMinMaxDescriptor,
+ const char* name = nullptr) override;
+
void VisitBatchToSpaceNdLayer(const armnn::IConnectableLayer* layer,
const armnn::BatchToSpaceNdDescriptor& descriptor,
const char* name = nullptr) override;
return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
}
+bool LayerSupportBase::IsArgMinMaxSupported(const armnn::TensorInfo &input, const armnn::TensorInfo &output,
+ const armnn::ArgMinMaxDescriptor& descriptor,
+ armnn::Optional<std::string &> reasonIfUnsupported) const
+{
+ return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
+}
+
bool LayerSupportBase::IsBatchNormalizationSupported(const TensorInfo& input,
const TensorInfo& output,
const TensorInfo& mean,
const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsArgMinMaxSupported(const TensorInfo& input,
+ const TensorInfo& output,
+ const ArgMinMaxDescriptor& descriptor,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsBatchNormalizationSupported(const TensorInfo& input,
const TensorInfo& output,
const TensorInfo& mean,
ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
}
+void ArgMinMaxQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
+{
+ const std::string descriptorName{"ArgMinMaxQueueDescriptor"};
+
+ ValidateNumInputs(workloadInfo, descriptorName, 1);
+ ValidateNumOutputs(workloadInfo, descriptorName, 1);
+
+ const TensorInfo& inputTensorInfo = workloadInfo.m_InputTensorInfos[0];
+ const TensorInfo& outputTensorInfo = workloadInfo.m_OutputTensorInfos[0];
+
+ std::vector<DataType> supportedTypes =
+ {
+ DataType::Float16,
+ DataType::Float32,
+ DataType::QuantisedAsymm8,
+ DataType::QuantisedSymm16
+ };
+
+ ValidateDataTypes(inputTensorInfo, supportedTypes, descriptorName);
+ ValidateTensorDataTypesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
+ ValidateTensorShapesMatch(inputTensorInfo, outputTensorInfo, descriptorName, "input", "output");
+}
+
void SoftmaxQueueDescriptor::Validate(const WorkloadInfo& workloadInfo) const
{
const std::string descriptorName{"SoftmaxQueueDescriptor"};
void Validate(const WorkloadInfo& workloadInfo) const;
};
+struct ArgMinMaxQueueDescriptor : QueueDescriptorWithParameters<ArgMinMaxDescriptor>
+{
+ void Validate(const WorkloadInfo& workloadInfo) const;
+};
+
// Fully connected layer workload data.
struct FullyConnectedQueueDescriptor : QueueDescriptorWithParameters<FullyConnectedDescriptor>
{
struct SplitterQueueDescriptor;
struct ConcatQueueDescriptor;
struct ActivationQueueDescriptor;
+struct ArgMinMaxQueueDescriptor;
struct FullyConnectedQueueDescriptor;
struct PermuteQueueDescriptor;
struct Pooling2dQueueDescriptor;
reason);
break;
}
+ case LayerType::ArgMinMax:
+ {
+ auto cLayer = boost::polymorphic_downcast<const ArgMinMaxLayer*>(&layer);
+ const ArgMinMaxDescriptor& descriptor = cLayer->GetParameters();
+
+ const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
+ const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+ result = layerSupportObject->IsArgMinMaxSupported(
+ OverrideDataType(input, dataType),
+ OverrideDataType(output, dataType),
+ descriptor,
+ reason);
+ break;
+ }
case LayerType::BatchNormalization:
{
auto cLayer = boost::polymorphic_downcast<const BatchNormalizationLayer*>(&layer);
return std::unique_ptr<IWorkload>();
}
+std::unique_ptr<IWorkload> IWorkloadFactory::CreateArgMinMax(const ArgMinMaxQueueDescriptor& descriptor,
+ const WorkloadInfo& info) const
+{
+ return std::unique_ptr<IWorkload>();
+}
+
std::unique_ptr<IWorkload> IWorkloadFactory::CreateBatchNormalization(
const BatchNormalizationQueueDescriptor& descriptor, const WorkloadInfo& info) const
{
virtual std::unique_ptr<IWorkload> CreateAddition(const AdditionQueueDescriptor& descriptor,
const WorkloadInfo& info) const;
+ virtual std::unique_ptr<IWorkload> CreateArgMinMax(const ArgMinMaxQueueDescriptor& descriptor,
+ const WorkloadInfo& info) const;
+
virtual std::unique_ptr<IWorkload> CreateBatchNormalization(const BatchNormalizationQueueDescriptor& descriptor,
const WorkloadInfo& info) const;
DECLARE_LAYER_POLICY_1_PARAM(Addition)
+DECLARE_LAYER_POLICY_2_PARAM(ArgMinMax)
+
DECLARE_LAYER_POLICY_2_PARAM(BatchNormalization)
DECLARE_LAYER_POLICY_2_PARAM(BatchToSpaceNd)