Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
virtual bool IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const = 0;
virtual bool IsRsqrtSupported(const TensorInfo& input,
/// Deprecated in favor of IBackend and ILayerSupport interfaces
bool IsResizeBilinearSupported(const BackendId& backend,
const TensorInfo& input,
+ const TensorInfo& output,
char* reasonIfUnsupported = nullptr,
size_t reasonIfUnsupportedMaxLength = 1024);
bool IsResizeBilinearSupported(const BackendId& backend,
const TensorInfo& input,
+ const TensorInfo& output,
char* reasonIfUnsupported,
size_t reasonIfUnsupportedMaxLength)
{
- FORWARD_LAYER_SUPPORT_FUNC(backend, IsResizeBilinearSupported, input);
+ FORWARD_LAYER_SUPPORT_FUNC(backend, IsResizeBilinearSupported, input, output);
}
bool IsRsqrtSupported(const BackendId& backend,
}
bool LayerSupportBase::IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
return DefaultLayerSupport(__func__, __FILE__, __LINE__, reasonIfUnsupported);
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsRsqrtSupported(const TensorInfo& input,
case LayerType::ResizeBilinear:
{
const TensorInfo& input = layer.GetInputSlot(0).GetConnection()->GetTensorInfo();
- result = layerSupportObject->IsResizeBilinearSupported(OverrideDataType(input, dataType), reason);
+ const TensorInfo& output = layer.GetOutputSlot(0).GetTensorInfo();
+ result = layerSupportObject->IsResizeBilinearSupported(OverrideDataType(input, dataType),
+ OverrideDataType(output, dataType),
+ reason);
break;
}
case LayerType::Rsqrt:
}
bool ClLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
+ ignore_unused(output);
return IsSupportedForDataTypeCl(reasonIfUnsupported,
input.GetDataType(),
&TrueFunc<>,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsSoftmaxSupported(const TensorInfo& input,
#include "workloads/NeonFullyConnectedWorkload.hpp"
#include "workloads/NeonPermuteWorkload.hpp"
#include "workloads/NeonPooling2dWorkload.hpp"
+#include "workloads/NeonResizeBilinearWorkload.hpp"
#include "workloads/NeonSoftmaxBaseWorkload.hpp"
#include "workloads/NeonSubtractionFloatWorkload.hpp"
#endif
&TrueFunc<>);
}
+bool NeonLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
+ Optional<std::string&> reasonIfUnsupported) const
+{
+ FORWARD_WORKLOAD_VALIDATE_FUNC(NeonResizeBilinearWorkloadValidate,
+ reasonIfUnsupported,
+ input,
+ output);
+}
+
bool NeonLayerSupport::IsSoftmaxSupported(const TensorInfo& input,
const TensorInfo& output,
const SoftmaxDescriptor& descriptor,
const ReshapeDescriptor& descriptor,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+ bool IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
+ Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
+
bool IsSoftmaxSupported(const TensorInfo& input,
const TensorInfo& output,
const SoftmaxDescriptor& descriptor,
const ResizeBilinearQueueDescriptor& descriptor,
const WorkloadInfo& info) const
{
- return nullptr;
+ return std::make_unique<NeonResizeBilinearWorkload>(descriptor, info);
}
std::unique_ptr<IWorkload> NeonWorkloadFactory::CreateFakeQuantization(
workloads/NeonPermuteWorkload.cpp \
workloads/NeonPooling2dWorkload.cpp \
workloads/NeonReshapeWorkload.cpp \
+ workloads/NeonResizeBilinearWorkload.cpp \
workloads/NeonSoftmaxBaseWorkload.cpp \
workloads/NeonSoftmaxFloatWorkload.cpp \
workloads/NeonSoftmaxUint8Workload.cpp \
ARMNN_AUTO_TEST_CASE(SimpleNormalizationWithin, SimpleNormalizationWithinTest)
ARMNN_AUTO_TEST_CASE(SimpleNormalizationAcrossNhwc, SimpleNormalizationAcrossNhwcTest)
+// Resize Bilinear - NCHW data layout
+ARMNN_AUTO_TEST_CASE(ResizeBilinearNop, ResizeBilinearNopTest, armnn::DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE(SimpleResizeBilinear, SimpleResizeBilinearTest, armnn::DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMin, ResizeBilinearSqMinTest, armnn::DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearMin, ResizeBilinearMinTest, armnn::DataLayout::NCHW)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearMag, ResizeBilinearMagTest, armnn::DataLayout::NCHW)
+
+// Resize Bilinear - NHWC data layout
+ARMNN_AUTO_TEST_CASE(ResizeBilinearNopNhwc, ResizeBilinearNopTest, armnn::DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE(SimpleResizeBilinearNhwc, SimpleResizeBilinearTest, armnn::DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearSqMinNhwc, ResizeBilinearSqMinTest, armnn::DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearMinNhwc, ResizeBilinearMinTest, armnn::DataLayout::NHWC)
+ARMNN_AUTO_TEST_CASE(ResizeBilinearMagNhwc, ResizeBilinearMagTest, armnn::DataLayout::NHWC)
+
// ============================================================================
// COMPARE tests
NeonPooling2dWorkload.hpp
NeonReshapeWorkload.cpp
NeonReshapeWorkload.hpp
+ NeonResizeBilinearWorkload.cpp
+ NeonResizeBilinearWorkload.hpp
NeonSoftmaxBaseWorkload.cpp
NeonSoftmaxBaseWorkload.hpp
NeonSoftmaxFloatWorkload.cpp
--- /dev/null
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "NeonResizeBilinearWorkload.hpp"
+
+#include <aclCommon/ArmComputeUtils.hpp>
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <backendsCommon/CpuTensorHandle.hpp>
+#include <neon/NeonTensorHandle.hpp>
+#include <neon/NeonLayerSupport.hpp>
+
+using namespace armnn::armcomputetensorutils;
+
+namespace armnn
+{
+
+arm_compute::Status NeonResizeBilinearWorkloadValidate(const TensorInfo& input, const TensorInfo& output)
+{
+ const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
+ const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
+
+ return arm_compute::NEScale::validate(&aclInputInfo,
+ &aclOutputInfo,
+ arm_compute::InterpolationPolicy::BILINEAR,
+ arm_compute::BorderMode::REPLICATE,
+ arm_compute::PixelValue(0.f),
+ arm_compute::SamplingPolicy::TOP_LEFT);
+}
+
+NeonResizeBilinearWorkload::NeonResizeBilinearWorkload(const ResizeBilinearQueueDescriptor& descriptor,
+ const WorkloadInfo& info)
+ : BaseWorkload<ResizeBilinearQueueDescriptor>(descriptor, info)
+{
+ m_Data.ValidateInputsOutputs("NeonResizeBilinearWorkload", 1, 1);
+
+ arm_compute::ITensor& input = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+ arm_compute::ITensor& output = boost::polymorphic_downcast<INeonTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
+
+ arm_compute::DataLayout aclDataLayout = ConvertDataLayout(m_Data.m_Parameters.m_DataLayout);
+ input.info()->set_data_layout(aclDataLayout);
+ output.info()->set_data_layout(aclDataLayout);
+
+ m_ResizeBilinearLayer.configure(&input,
+ &output,
+ arm_compute::InterpolationPolicy::BILINEAR,
+ arm_compute::BorderMode::REPLICATE,
+ arm_compute::PixelValue(0.f),
+ arm_compute::SamplingPolicy::TOP_LEFT);
+};
+
+void NeonResizeBilinearWorkload::Execute() const
+{
+ ARMNN_SCOPED_PROFILING_EVENT_NEON("NeonResizeBilinearWorkload_Execute");
+ m_ResizeBilinearLayer.run();
+}
+
+} //namespace armnn
--- /dev/null
+//
+// Copyright © 2017 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <backendsCommon/Workload.hpp>
+
+#include <neon/workloads/NeonWorkloadUtils.hpp>
+
+#include <arm_compute/runtime/NEON/functions/NEScale.h>
+
+namespace armnn
+{
+
+arm_compute::Status NeonResizeBilinearWorkloadValidate(const TensorInfo& input, const TensorInfo& output);
+
+class NeonResizeBilinearWorkload : public BaseWorkload<ResizeBilinearQueueDescriptor>
+{
+public:
+ NeonResizeBilinearWorkload(const ResizeBilinearQueueDescriptor& descriptor, const WorkloadInfo& info);
+ void Execute() const override;
+
+private:
+ mutable arm_compute::NEScale m_ResizeBilinearLayer;
+};
+
+} //namespace armnn
#include "NeonPermuteWorkload.hpp"
#include "NeonPooling2dWorkload.hpp"
#include "NeonReshapeWorkload.hpp"
+#include "NeonResizeBilinearWorkload.hpp"
#include "NeonSoftmaxFloatWorkload.hpp"
#include "NeonSoftmaxUint8Workload.hpp"
#include "NeonSplitterWorkload.hpp"
}
bool RefLayerSupport::IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported) const
{
+ ignore_unused(output);
return IsSupportedForDataTypeRef(reasonIfUnsupported,
input.GetDataType(),
&TrueFunc<>,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsResizeBilinearSupported(const TensorInfo& input,
+ const TensorInfo& output,
Optional<std::string&> reasonIfUnsupported = EmptyOptional()) const override;
bool IsRsqrtSupported(const TensorInfo& input,