IVGCVSW-4753 Refactor CL Softmax workload generalizing for different datatype

    * Change ComputeSoftmaxAclAxis to work with int and uint axis

Signed-off-by: Teresa Charlin <teresa.charlinreyes@arm.com>
Change-Id: Ibbfa9ec7e2f0416e6885673212a767419c871cca

diff --git a/src/backends/aclCommon/ArmComputeUtils.hpp b/src/backends/aclCommon/ArmComputeUtils.hpp
index 80bb762..d8818ce 100644 (file)
--- a/src/backends/aclCommon/ArmComputeUtils.hpp
+++ b/src/backends/aclCommon/ArmComputeUtils.hpp
@@ -150,7 +150,8 @@ inline arm_compute::InterpolationPolicy ConvertResizeMethodToAclInterpolationPol
     }
 }
 
-inline unsigned int ComputeSoftmaxAclAxis(const SoftmaxDescriptor& softmaxDesc, const armnn::TensorInfo& tensor)
+template<typename T>
+inline T ComputeSoftmaxAclAxis(const SoftmaxDescriptor& softmaxDesc, const armnn::TensorInfo& tensor)
 {
     // Detect the Android default value of -1 and return the ACL default value of 1.
     if (softmaxDesc.m_Axis == -1)
@@ -163,7 +164,7 @@ inline unsigned int ComputeSoftmaxAclAxis(const SoftmaxDescriptor& softmaxDesc,
     ARMNN_ASSERT(dim != 0);
 
     // Currently ArmNN support axis 1.
-    return dim - 1;
+    return static_cast<T>(dim) - 1;
 }
 
 inline std::set<unsigned int> ComputeSplitAxis(const armnn::SplitterDescriptor& desc, const TensorShape& input)

diff --git a/src/backends/cl/ClLayerSupport.cpp b/src/backends/cl/ClLayerSupport.cpp
index 546cbc1..eb68a80 100644 (file)
--- a/src/backends/cl/ClLayerSupport.cpp
+++ b/src/backends/cl/ClLayerSupport.cpp
@@ -53,7 +53,7 @@
 #include "workloads/ClQuantizedLstmWorkload.hpp"
 #include "workloads/ClQuantizeWorkload.hpp"
 #include "workloads/ClSliceWorkload.hpp"
-#include "workloads/ClSoftmaxBaseWorkload.hpp"
+#include "workloads/ClSoftmaxWorkload.hpp"
 #include "workloads/ClSpaceToBatchNdWorkload.hpp"
 #include "workloads/ClSpaceToDepthWorkload.hpp"
 #include "workloads/ClSplitterWorkload.hpp"

diff --git a/src/backends/cl/ClWorkloadFactory.cpp b/src/backends/cl/ClWorkloadFactory.cpp
index b0d2fdf..f584272 100644 (file)
--- a/src/backends/cl/ClWorkloadFactory.cpp
+++ b/src/backends/cl/ClWorkloadFactory.cpp
@@ -490,8 +490,7 @@ std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSlice(const SliceQueueDescri
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSoftmax(const SoftmaxQueueDescriptor& descriptor,
                                                             const WorkloadInfo& info) const
 {
-    return MakeWorkload<ClSoftmaxFloatWorkload, ClSoftmaxUint8Workload>(descriptor, info,
-                                                                        m_MemoryManager->GetIntraLayerManager());
+    return std::make_unique<ClSoftmaxWorkload>(descriptor, info, m_MemoryManager->GetIntraLayerManager());
 }
 
 std::unique_ptr<IWorkload> ClWorkloadFactory::CreateSpaceToBatchNd(const SpaceToBatchNdQueueDescriptor& descriptor,

diff --git a/src/backends/cl/backend.mk b/src/backends/cl/backend.mk
index 3f2e808..8b464bb 100644 (file)
--- a/src/backends/cl/backend.mk
+++ b/src/backends/cl/backend.mk
@@ -59,9 +59,7 @@ BACKEND_SOURCES := \
         workloads/ClResizeWorkload.cpp \
         workloads/ClRsqrtWorkload.cpp \
         workloads/ClSliceWorkload.cpp \
-        workloads/ClSoftmaxBaseWorkload.cpp \
-        workloads/ClSoftmaxFloatWorkload.cpp \
-        workloads/ClSoftmaxUint8Workload.cpp \
+        workloads/ClSoftmaxWorkload.cpp \
         workloads/ClSpaceToBatchNdWorkload.cpp \
         workloads/ClSpaceToDepthWorkload.cpp \
         workloads/ClSplitterWorkload.cpp \

diff --git a/src/backends/cl/test/ClCreateWorkloadTests.cpp b/src/backends/cl/test/ClCreateWorkloadTests.cpp
index b09b26f..b752254 100644 (file)
--- a/src/backends/cl/test/ClCreateWorkloadTests.cpp
+++ b/src/backends/cl/test/ClCreateWorkloadTests.cpp
@@ -569,19 +569,41 @@ static void ClSoftmaxWorkloadTest()
     auto inputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Inputs[0]);
     auto outputHandle = PolymorphicDowncast<IClTensorHandle*>(queueDescriptor.m_Outputs[0]);
 
+    armnn::TensorInfo tensorInfo({4, 1}, DataType);
+    if (DataType == armnn::DataType::QAsymmU8)
+    {
+        tensorInfo.SetQuantizationOffset(0);
+        tensorInfo.SetQuantizationScale(1.f / 256);
+    }
+    else if (DataType == armnn::DataType::QAsymmS8)
+    {
+        tensorInfo.SetQuantizationOffset(-128);
+        tensorInfo.SetQuantizationScale(1.f / 256);
+    }
+
     BOOST_TEST(CompareIClTensorHandleShape(inputHandle, {4, 1}));
     BOOST_TEST(CompareIClTensorHandleShape(outputHandle, {4, 1}));
 }
 
 
-BOOST_AUTO_TEST_CASE(CreateSoftmaxFloatWorkloadTest)
+BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat32WorkloadTest)
 {
-    ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float32>();
+    ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float32>();
 }
 
 BOOST_AUTO_TEST_CASE(CreateSoftmaxFloat16WorkloadTest)
 {
-    ClSoftmaxWorkloadTest<ClSoftmaxFloatWorkload, armnn::DataType::Float16>();
+    ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::Float16>();
+}
+
+BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmU8Workload)
+{
+    ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmU8>();
+}
+
+BOOST_AUTO_TEST_CASE(CreateSoftmaxQAsymmS8Workload)
+{
+    ClSoftmaxWorkloadTest<ClSoftmaxWorkload, armnn::DataType::QAsymmS8>();
 }
 
 template <typename armnn::DataType DataType>

diff --git a/src/backends/cl/workloads/CMakeLists.txt b/src/backends/cl/workloads/CMakeLists.txt
index 161ad96..e595028 100644 (file)
--- a/src/backends/cl/workloads/CMakeLists.txt
+++ b/src/backends/cl/workloads/CMakeLists.txt
@@ -78,12 +78,8 @@ list(APPEND armnnClBackendWorkloads_sources
     ClRsqrtWorkload.hpp
     ClSliceWorkload.cpp
     ClSliceWorkload.hpp
-    ClSoftmaxBaseWorkload.cpp
-    ClSoftmaxBaseWorkload.hpp
-    ClSoftmaxFloatWorkload.cpp
-    ClSoftmaxFloatWorkload.hpp
-    ClSoftmaxUint8Workload.cpp
-    ClSoftmaxUint8Workload.hpp
+    ClSoftmaxWorkload.cpp
+    ClSoftmaxWorkload.hpp
     ClSpaceToBatchNdWorkload.hpp
     ClSpaceToBatchNdWorkload.cpp
     ClSpaceToDepthWorkload.cpp

diff --git a/src/backends/cl/workloads/ClSoftmaxBaseWorkload.cpp b/src/backends/cl/workloads/ClSoftmaxBaseWorkload.cpp
deleted file mode 100644 (file)
index a355ba0..0000000
--- a/src/backends/cl/workloads/ClSoftmaxBaseWorkload.cpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "ClSoftmaxBaseWorkload.hpp"
-
-#include <aclCommon/ArmComputeTensorUtils.hpp>
-#include <aclCommon/ArmComputeUtils.hpp>
-
-#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
-
-namespace armnn
-{
-
-arm_compute::Status ClSoftmaxWorkloadValidate(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const SoftmaxDescriptor& descriptor)
-{
-    const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
-    const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
-
-    unsigned int aclAxis = ComputeSoftmaxAclAxis(descriptor, input);
-    return arm_compute::CLSoftmaxLayer::validate(&aclInputInfo, &aclOutputInfo, descriptor.m_Beta, aclAxis);
-}
-
-}

diff --git a/src/backends/cl/workloads/ClSoftmaxBaseWorkload.hpp b/src/backends/cl/workloads/ClSoftmaxBaseWorkload.hpp
deleted file mode 100644 (file)
index 8d73060..0000000
--- a/src/backends/cl/workloads/ClSoftmaxBaseWorkload.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include <armnn/Descriptors.hpp>
-#include <armnn/Tensor.hpp>
-#include <arm_compute/core/Error.h>
-
-namespace armnn
-{
-
-arm_compute::Status ClSoftmaxWorkloadValidate(const TensorInfo& input,
-                                              const TensorInfo& output,
-                                              const SoftmaxDescriptor& descriptor);
-
-} // namespace armnn

diff --git a/src/backends/cl/workloads/ClSoftmaxFloatWorkload.cpp b/src/backends/cl/workloads/ClSoftmaxFloatWorkload.cpp
deleted file mode 100644 (file)
index adb4872..0000000
--- a/src/backends/cl/workloads/ClSoftmaxFloatWorkload.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "ClSoftmaxFloatWorkload.hpp"
-#include "ClWorkloadUtils.hpp"
-
-#include <aclCommon/ArmComputeUtils.hpp>
-#include <cl/ClTensorHandle.hpp>
-#include <backendsCommon/CpuTensorHandle.hpp>
-
-namespace armnn
-{
-
-ClSoftmaxFloatWorkload::ClSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
-                                               std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
-    : FloatWorkload<SoftmaxQueueDescriptor>(descriptor, info)
-    , m_SoftmaxLayer(memoryManager)
-{
-    m_Data.ValidateInputsOutputs("ClSoftmaxFloatWorkload", 1, 1);
-
-    arm_compute::ICLTensor& input  = static_cast<ClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
-    arm_compute::ICLTensor& output = static_cast<ClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
-
-    unsigned int aclAxis = ComputeSoftmaxAclAxis(m_Data.m_Parameters, info.m_InputTensorInfos[0]);
-    m_SoftmaxLayer.configure(&input, &output, m_Data.m_Parameters.m_Beta, aclAxis);
-}
-
-void ClSoftmaxFloatWorkload::Execute() const
-{
-    ARMNN_SCOPED_PROFILING_EVENT_CL("ClSoftmaxFloatWorkload_Execute");
-    RunClFunction(m_SoftmaxLayer, CHECK_LOCATION());
-}
-
-} //namespace armnn

diff --git a/src/backends/cl/workloads/ClSoftmaxFloatWorkload.hpp b/src/backends/cl/workloads/ClSoftmaxFloatWorkload.hpp
deleted file mode 100644 (file)
index 7efdae8..0000000
--- a/src/backends/cl/workloads/ClSoftmaxFloatWorkload.hpp
+++ /dev/null
@@ -1,30 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include <backendsCommon/Workload.hpp>
-
-#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
-#include <arm_compute/runtime/MemoryManagerOnDemand.h>
-
-#include <memory>
-
-namespace armnn
-{
-
-class ClSoftmaxFloatWorkload : public FloatWorkload<SoftmaxQueueDescriptor>
-{
-public:
-    ClSoftmaxFloatWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
-                             std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
-    void Execute() const override;
-
-private:
-    mutable arm_compute::CLSoftmaxLayer m_SoftmaxLayer;
-};
-
-} //namespace armnn
-

diff --git a/src/backends/cl/workloads/ClSoftmaxUint8Workload.cpp b/src/backends/cl/workloads/ClSoftmaxUint8Workload.cpp
deleted file mode 100644 (file)
index f14ea11..0000000
--- a/src/backends/cl/workloads/ClSoftmaxUint8Workload.cpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#include "ClSoftmaxUint8Workload.hpp"
-#include "ClWorkloadUtils.hpp"
-
-#include <aclCommon/ArmComputeUtils.hpp>
-#include <cl/ClTensorHandle.hpp>
-#include <backendsCommon/CpuTensorHandle.hpp>
-
-namespace armnn
-{
-
-ClSoftmaxUint8Workload::ClSoftmaxUint8Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
-                                               std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
-    : Uint8Workload<SoftmaxQueueDescriptor>(descriptor, info)
-    , m_SoftmaxLayer(memoryManager)
-{
-    m_Data.ValidateInputsOutputs("ClSoftmaxUint8Workload", 1, 1);
-
-    arm_compute::ICLTensor& input  = static_cast<ClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
-    arm_compute::ICLTensor& output = static_cast<ClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
-
-    const auto outputQuantization = output.info()->quantization_info();
-
-    if ((!outputQuantization.scale().empty() && outputQuantization.scale()[0] != (1.0f / 256.0f)) ||
-        (!outputQuantization.offset().empty() && outputQuantization.offset()[0] != 0) ||
-         outputQuantization.scale().empty() || outputQuantization.offset().empty())
-    {
-        throw InvalidArgumentException(
-            "Invalid quantization for output. Only scale = 1.0f / 256.0f and offset = 0 supported");
-    }
-
-    unsigned int aclAxis = ComputeSoftmaxAclAxis(m_Data.m_Parameters, info.m_InputTensorInfos[0]);
-    m_SoftmaxLayer.configure(&input, &output, descriptor.m_Parameters.m_Beta, aclAxis);
-}
-
-void ClSoftmaxUint8Workload::Execute() const
-{
-    ARMNN_SCOPED_PROFILING_EVENT_CL("ClSoftmaxUint8Workload_Execute");
-    RunClFunction(m_SoftmaxLayer, CHECK_LOCATION());
-}
-
-} //namespace armnn

diff --git a/src/backends/cl/workloads/ClSoftmaxUint8Workload.hpp b/src/backends/cl/workloads/ClSoftmaxUint8Workload.hpp
deleted file mode 100644 (file)
index f378b89..0000000
--- a/src/backends/cl/workloads/ClSoftmaxUint8Workload.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Copyright © 2017 Arm Ltd. All rights reserved.
-// SPDX-License-Identifier: MIT
-//
-
-#pragma once
-
-#include <backendsCommon/Workload.hpp>
-
-#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
-#include <arm_compute/runtime/MemoryManagerOnDemand.h>
-
-#include <memory>
-
-namespace armnn
-{
-// Softmax
-class ClSoftmaxUint8Workload : public Uint8Workload<SoftmaxQueueDescriptor>
-{
-public:
-    ClSoftmaxUint8Workload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
-                           std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
-
-    void Execute() const override;
-private:
-
-    mutable arm_compute::CLSoftmaxLayer m_SoftmaxLayer;
-};
-
-} //namespace armnn
-

diff --git a/src/backends/cl/workloads/ClSoftmaxWorkload.cpp b/src/backends/cl/workloads/ClSoftmaxWorkload.cpp
new file mode 100644 (file)
index 0000000..cbca766
--- /dev/null
+++ b/src/backends/cl/workloads/ClSoftmaxWorkload.cpp
@@ -0,0 +1,48 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#include "ClSoftmaxWorkload.hpp"
+#include "ClWorkloadUtils.hpp"
+
+#include <aclCommon/ArmComputeTensorUtils.hpp>
+#include <aclCommon/ArmComputeUtils.hpp>
+
+#include <cl/ClTensorHandle.hpp>
+
+namespace armnn
+{
+
+arm_compute::Status ClSoftmaxWorkloadValidate(const TensorInfo& input,
+                                              const TensorInfo& output,
+                                              const SoftmaxDescriptor& descriptor)
+{
+    const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
+    const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
+
+    unsigned int aclAxis = ComputeSoftmaxAclAxis<unsigned int>(descriptor, input);
+    return arm_compute::CLSoftmaxLayer::validate(&aclInputInfo, &aclOutputInfo, descriptor.m_Beta, aclAxis);
+}
+
+ClSoftmaxWorkload::ClSoftmaxWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
+                                     std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager)
+        : BaseWorkload<SoftmaxQueueDescriptor>(descriptor, info)
+        , m_SoftmaxLayer(memoryManager)
+{
+    m_Data.ValidateInputsOutputs("ClSoftmaxWorkload", 1, 1);
+
+    arm_compute::ICLTensor& input  = static_cast<ClTensorHandle*>(m_Data.m_Inputs[0])->GetTensor();
+    arm_compute::ICLTensor& output = static_cast<ClTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
+
+    unsigned int aclAxis = ComputeSoftmaxAclAxis<unsigned int>(m_Data.m_Parameters, info.m_InputTensorInfos[0]);
+    m_SoftmaxLayer.configure(&input, &output, m_Data.m_Parameters.m_Beta, aclAxis);
+}
+
+void ClSoftmaxWorkload::Execute() const
+{
+    ARMNN_SCOPED_PROFILING_EVENT_CL("ClSoftmaxWorkload_Execute");
+    RunClFunction(m_SoftmaxLayer, CHECK_LOCATION());
+}
+
+} // namespace armnn

diff --git a/src/backends/cl/workloads/ClSoftmaxWorkload.hpp b/src/backends/cl/workloads/ClSoftmaxWorkload.hpp
new file mode 100644 (file)
index 0000000..158bf46
--- /dev/null
+++ b/src/backends/cl/workloads/ClSoftmaxWorkload.hpp
@@ -0,0 +1,34 @@
+//
+// Copyright © 2020 Arm Ltd. All rights reserved.
+// SPDX-License-Identifier: MIT
+//
+
+#pragma once
+
+#include <armnn/Descriptors.hpp>
+
+#include <arm_compute/core/Error.h>
+#include <arm_compute/runtime/MemoryManagerOnDemand.h>
+#include <arm_compute/runtime/CL/functions/CLSoftmaxLayer.h>
+
+#include <backendsCommon/Workload.hpp>
+
+namespace armnn
+{
+
+arm_compute::Status ClSoftmaxWorkloadValidate(const TensorInfo& input,
+                                              const TensorInfo& output,
+                                              const SoftmaxDescriptor& descriptor);
+
+class ClSoftmaxWorkload : public BaseWorkload<SoftmaxQueueDescriptor>
+{
+public:
+    ClSoftmaxWorkload(const SoftmaxQueueDescriptor& descriptor, const WorkloadInfo& info,
+                      std::shared_ptr<arm_compute::MemoryManagerOnDemand>& memoryManager);
+    void Execute() const override;
+
+private:
+    mutable arm_compute::CLSoftmaxLayer m_SoftmaxLayer;
+};
+
+} // namespace armnn

diff --git a/src/backends/cl/workloads/ClWorkloads.hpp b/src/backends/cl/workloads/ClWorkloads.hpp
index ffe66a0..62b73da 100644 (file)
--- a/src/backends/cl/workloads/ClWorkloads.hpp
+++ b/src/backends/cl/workloads/ClWorkloads.hpp
@@ -39,8 +39,7 @@
 #include "ClResizeWorkload.hpp"
 #include "ClRsqrtWorkload.hpp"
 #include "ClSliceWorkload.hpp"
-#include "ClSoftmaxFloatWorkload.hpp"
-#include "ClSoftmaxUint8Workload.hpp"
+#include "ClSoftmaxWorkload.hpp"
 #include "ClSpaceToBatchNdWorkload.hpp"
 #include "ClSpaceToDepthWorkload.hpp"
 #include "ClSplitterWorkload.hpp"

diff --git a/src/backends/neon/workloads/NeonSoftmaxWorkload.cpp b/src/backends/neon/workloads/NeonSoftmaxWorkload.cpp
index 149804b..35e2e0e 100644 (file)
--- a/src/backends/neon/workloads/NeonSoftmaxWorkload.cpp
+++ b/src/backends/neon/workloads/NeonSoftmaxWorkload.cpp
@@ -23,7 +23,7 @@ arm_compute::Status NeonSoftmaxWorkloadValidate(const TensorInfo& input,
     const arm_compute::TensorInfo aclInputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(input);
     const arm_compute::TensorInfo aclOutputInfo = armcomputetensorutils::BuildArmComputeTensorInfo(output);
 
-    unsigned int aclAxis = ComputeSoftmaxAclAxis(descriptor, input);
+    unsigned int aclAxis = ComputeSoftmaxAclAxis<unsigned int>(descriptor, input);
     return arm_compute::NESoftmaxLayer::validate(&aclInputInfo, &aclOutputInfo, descriptor.m_Beta, aclAxis);
 }
 
@@ -38,7 +38,7 @@ NeonSoftmaxWorkload::NeonSoftmaxWorkload(const SoftmaxQueueDescriptor& descripto
     arm_compute::ITensor& output = PolymorphicDowncast<IAclTensorHandle*>(m_Data.m_Outputs[0])->GetTensor();
 
     auto layer = std::make_unique<arm_compute::NESoftmaxLayer>(memoryManager);
-    unsigned int aclAxis = ComputeSoftmaxAclAxis(m_Data.m_Parameters, info.m_InputTensorInfos[0]);
+    unsigned int aclAxis = ComputeSoftmaxAclAxis<unsigned int>(m_Data.m_Parameters, info.m_InputTensorInfos[0]);
     layer->configure(&input, &output, m_Data.m_Parameters.m_Beta, aclAxis);
     m_SoftmaxLayer.reset(layer.release());
 }