From 31c39be002b9e9040b2306e2461ee228853b4ed6 Mon Sep 17 00:00:00 2001 From: Teresa Charlin Date: Thu, 26 Nov 2020 16:54:15 +0000 Subject: IVGCVSW-5568 Revert "IVGCVSW-5563 Fix Crash on model with FullyConnected Sigmoid Activation" * This reverts commit be25d94aefe53f221304b1f5f344913b708f808b. * Add Unit Test: any receiver layer + any activation layer in float and QAsymmU8 * Tidy up fuse activation tests Signed-off-by: Teresa Charlin Change-Id: Ie059d03b85cd17eaaafe5188bb173672a1fb9ae0 --- .../test/optimizations/FuseActivationTests.cpp | 476 ++++++++++++++++----- 1 file changed, 374 insertions(+), 102 deletions(-) (limited to 'src/armnn') diff --git a/src/armnn/test/optimizations/FuseActivationTests.cpp b/src/armnn/test/optimizations/FuseActivationTests.cpp index 0e855977a0..f28abff1e7 100644 --- a/src/armnn/test/optimizations/FuseActivationTests.cpp +++ b/src/armnn/test/optimizations/FuseActivationTests.cpp @@ -19,10 +19,8 @@ using namespace armnn; BOOST_AUTO_TEST_SUITE(Optimizer) -namespace +namespace armnn { -const float g_qScale = 1.0f; -const int32_t g_qOffset = 0; template std::vector GetVector(unsigned int size, float initial, float increment) @@ -40,10 +38,10 @@ std::vector GetVector(unsigned int size, float initial, float increment) return vector; } -template> +template> struct Convolution2dTest { - using LayerType = armnn::Convolution2dLayer; + using LayerType = Convolution2dLayer; static std::string GetReceiverLayerName() { return "Convolution2d"; }; static const bool isElementWise = false; @@ -55,7 +53,9 @@ struct Convolution2dTest constexpr static const unsigned int outputSize = 36; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { Convolution2dDescriptor descriptor; descriptor.m_BiasEnabled = false; @@ -67,8 +67,8 @@ struct Convolution2dTest 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42}; - std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, g_qScale, g_qOffset); - TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset); + std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, scale, offset); + TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, scale, offset); ConstTensor weights(weightsInfo, weightsVector); Optional optionalBias; @@ -76,11 +76,11 @@ struct Convolution2dTest } }; -template> -struct DepthwiseConvolution2dTest +template> +struct DWConvolution2dTest { public: - using LayerType = armnn::DepthwiseConvolution2dLayer; + using LayerType = DepthwiseConvolution2dLayer; static std::string GetReceiverLayerName() { return "DepthwiseConvolution2d"; }; static const bool isElementWise = false; @@ -92,7 +92,9 @@ public: constexpr static const unsigned int outputSize = 108; //batchOut * heightOut * widthOut * channelOut; static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { DepthwiseConvolution2dDescriptor descriptor; descriptor.m_BiasEnabled = false; @@ -104,8 +106,8 @@ public: 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42}; - std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, g_qScale, g_qOffset); - TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset); + std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, scale, offset); + TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, scale, offset); ConstTensor weights(weightsInfo, weightsVector); Optional optionalBias; @@ -113,11 +115,11 @@ public: } }; -template> +template> struct FullyConnectedTest { public: - using LayerType = armnn::FullyConnectedLayer; + using LayerType = FullyConnectedLayer; static std::string GetReceiverLayerName() { return "FullyConnected"; }; static const bool isElementWise = false; @@ -129,7 +131,9 @@ public: constexpr static const unsigned int outputSize = 6; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { FullyConnectedDescriptor descriptor; descriptor.m_BiasEnabled = false; @@ -137,8 +141,8 @@ public: std::vector weightsData = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; - std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, g_qScale, g_qOffset); - TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, g_qScale, g_qOffset); + std::vector weightsVector = armnnUtils::QuantizedVector(weightsData, scale, offset); + TensorInfo weightsInfo(GetWeightsShape(), ArmnnType, scale, offset); ConstTensor weights(weightsInfo, weightsVector); Optional optionalBias; @@ -146,11 +150,11 @@ public: } }; -template> +template> struct BatchNormTest { public: - using LayerType = armnn::BatchNormalizationLayer; + using LayerType = BatchNormalizationLayer; static std::string GetReceiverLayerName() { return "BatchNorm"; }; static const bool isElementWise = false; @@ -161,8 +165,13 @@ public: constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { + IgnoreUnused(scale); + IgnoreUnused(offset); + BatchNormalizationDescriptor descriptor; descriptor.m_DataLayout = DataLayout::NHWC; @@ -181,10 +190,10 @@ public: } }; -template> +template> struct MultiplicationTest { - using LayerType = armnn::MultiplicationLayer; + using LayerType = MultiplicationLayer; static std::string GetReceiverLayerName() { return "Multiplication"; }; static const bool isElementWise = true; @@ -195,16 +204,21 @@ struct MultiplicationTest constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { + IgnoreUnused(scale); + IgnoreUnused(offset); + return network->AddMultiplicationLayer(name); } }; -template> +template> struct AdditionTest { - using LayerType = armnn::AdditionLayer; + using LayerType = AdditionLayer; static std::string GetReceiverLayerName() { return "Addition"; }; static const bool isElementWise = true; @@ -215,16 +229,21 @@ struct AdditionTest constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { + IgnoreUnused(scale); + IgnoreUnused(offset); + return network->AddAdditionLayer(name); } }; -template> +template> struct SubtractionTest { - using LayerType = armnn::SubtractionLayer; + using LayerType = SubtractionLayer; static std::string GetReceiverLayerName() { return "Subtraction"; }; static const bool isElementWise = true; @@ -235,16 +254,21 @@ struct SubtractionTest constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { + IgnoreUnused(scale); + IgnoreUnused(offset); + return network->AddSubtractionLayer(name); } }; -template> +template> struct DivisionTest { - using LayerType = armnn::DivisionLayer; + using LayerType = DivisionLayer; static std::string GetReceiverLayerName() { return "Division"; }; static const bool isElementWise = true; @@ -255,17 +279,21 @@ struct DivisionTest constexpr static const unsigned int outputSize = 48; // batchOut * heightOut * widthOut * channelOut static IConnectableLayer* AddReceiverLayer(INetwork* network, - const char* name) + const char* name, + float scale = 1.f, + int32_t offset = 0) { + IgnoreUnused(scale); + IgnoreUnused(offset); + return network->AddDivisionLayer(name); } }; -} // namespace - template -INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool preventFusing) + DataType ArmnnType> +INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool preventFusing, + float scale, int32_t offset) { // Create a network INetworkPtr network = INetwork::Create(); @@ -273,7 +301,9 @@ INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool prevent IConnectableLayer* inputLayer = network->AddInputLayer(0); IConnectableLayer* receiverLayer = LayerTest::AddReceiverLayer(network.get(), - "receiverLayer"); + "receiverLayer", + scale, + offset); IConnectableLayer* activationLayer = network->AddActivationLayer(activationDescriptor, "activation"); @@ -282,8 +312,8 @@ INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool prevent IConnectableLayer* output2Layer = preventFusing?network->AddOutputLayer(1):nullptr; // Define layers information - TensorInfo inputInfo(LayerTest::GetInputShape(), ArmnnType, g_qScale, g_qOffset); - TensorInfo outputInfo(LayerTest::GetOutputShape(), ArmnnType, g_qScale, g_qOffset); + TensorInfo inputInfo(LayerTest::GetInputShape(), ArmnnType, scale, offset); + TensorInfo outputInfo(LayerTest::GetOutputShape(), ArmnnType, scale, offset); // Set layer information inputLayer->GetOutputSlot(0).SetTensorInfo(inputInfo); @@ -308,15 +338,15 @@ INetworkPtr CreatNetwork(ActivationDescriptor activationDescriptor, bool prevent } template> -void FuseActivationIntoPreviousLayerTest(ActivationDescriptor activationDescriptor, float tolerance, armnn::Compute -backendId) + typename T = ResolveType> +void FuseActivationIntoPreviousLayerTest(ActivationDescriptor activationDescriptor, float tolerance, Compute backendId, + float scale = 1.f, int32_t offset=0) { // FIRST NETWORK: Fused // Construct ArmNN network - INetworkPtr networkFused = CreatNetwork(activationDescriptor, false); + INetworkPtr networkFused = CreatNetwork(activationDescriptor, false, scale, offset); // Create ArmNN runtime IRuntimePtr run = IRuntime::Create(IRuntime::CreationOptions()); // default options @@ -326,7 +356,7 @@ backendId) Graph graphFused = PolymorphicDowncast(optNetFused.get())->GetGraph(); - auto checkFusedConv2d = [](const armnn::Layer* const layer)->bool { + auto checkFusedConv2d = [](const Layer* const layer)->bool { return IsLayerOfType(layer) && (layer->GetNameStr() == "fused-activation-into-receiverLayer"); }; @@ -344,7 +374,7 @@ backendId) //Creates structures for inputs and outputs. std::vector data = GetVector(LayerTest::inputSize, 1.0f, 0.1f); - std::vector inputDataFused = armnnUtils::QuantizedVector(data, g_qScale, g_qOffset); + std::vector inputDataFused = armnnUtils::QuantizedVector(data, scale, offset); std::vector outputDataFused(LayerTest::outputSize); InputTensors inputTensorsFused{ @@ -357,7 +387,7 @@ backendId) // SECOND NETWORK: NotFused // Construct ArmNN network - INetworkPtr networkNotFused = CreatNetwork(activationDescriptor, true); + INetworkPtr networkNotFused = CreatNetwork(activationDescriptor, true, scale, offset); // Create ArmNN runtime IRuntimePtr runNotFused = IRuntime::Create(IRuntime::CreationOptions()); // default options @@ -370,18 +400,18 @@ backendId) BOOST_CHECK(5 == graphNotFused.GetNumLayers()); BOOST_TEST(CheckSequence(graphNotFused.cbegin(), graphNotFused.cend(), - &IsLayerOfType, + &IsLayerOfType, &IsLayerOfType, - &IsLayerOfType, - &IsLayerOfType, - &IsLayerOfType)); + &IsLayerOfType, + &IsLayerOfType, + &IsLayerOfType)); // Load network into runtime NetworkId networkIdentifierNotFused; BOOST_TEST(runNotFused->LoadNetwork(networkIdentifierNotFused, std::move(optNetNotFused)) == Status::Success); //Creates structures for inputs and outputs. - std::vector inputDataNotFused = armnnUtils::QuantizedVector(data, g_qScale, g_qOffset); + std::vector inputDataNotFused = armnnUtils::QuantizedVector(data, scale, offset); std::vector outputDataNotFused(LayerTest::outputSize); std::vector outputData2NotFused(LayerTest::outputSize); @@ -402,6 +432,58 @@ backendId) } } +template> +bool FuseActivationSimpleTest(ActivationDescriptor activationDescriptor, Compute backendId, + float scale = 1.f, int32_t offset = 0) +{ + bool success; + try + { + // Construct ArmNN network + INetworkPtr networkFused = CreatNetwork(activationDescriptor, false, scale, offset); + + // Create ArmNN runtime + IRuntimePtr run = IRuntime::Create(IRuntime::CreationOptions()); // default options + + // Optimise ArmNN network + IOptimizedNetworkPtr optNetFused = Optimize(*networkFused, {backendId}, run->GetDeviceSpec()); + + Graph graphFused = PolymorphicDowncast(optNetFused.get())->GetGraph(); + + // Load network into runtime + NetworkId networkIdentifier; + BOOST_TEST(run->LoadNetwork(networkIdentifier, std::move(optNetFused)) == Status::Success); + + //Creates structures for inputs and outputs. + std::vector data = GetVector(LayerTest::inputSize, 1.0f, 0.1f); + std::vector inputDataFused = armnnUtils::QuantizedVector(data, scale, offset); + std::vector outputDataFused(LayerTest::outputSize); + + InputTensors inputTensorsFused{ + {0, ConstTensor(run->GetInputTensorInfo(networkIdentifier, 0), inputDataFused.data())}}; + OutputTensors outputTensorsFused{ + {0, Tensor(run->GetOutputTensorInfo(networkIdentifier, 0), outputDataFused.data())}}; + + // Execute network + run->EnqueueWorkload(networkIdentifier, inputTensorsFused, outputTensorsFused); + + success = true; + } + catch (const std::exception& e) + { + std::cerr << e.what() << std::endl; + success = false; + } + + return success; +} + +} // namespace armnn + +using namespace armnn; #if defined(ARMCOMPUTENEON_ENABLED) // ReLu fused into Receiver Layers Float32 BOOST_AUTO_TEST_CASE(FuseReLUIntoConvFloat32CpuAccTest) @@ -410,15 +492,15 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoConvFloat32CpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvFloat32CpuAccTest) { ActivationDescriptor activationDescriptor; activationDescriptor.m_Function = ActivationFunction::ReLu; - FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + FuseActivationIntoPreviousLayerTest, DataType::Float32> + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32CpuAccTest) { @@ -426,7 +508,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32CpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32CpuAccTest) { @@ -434,7 +516,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32CpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } // BoundedReLu fused into Receiver Layers Float32 @@ -446,7 +528,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoConvFloat32CpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32CpuAccTest) { @@ -455,8 +537,8 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32CpuAccTest) activationDescriptor.m_A = 1.0f; activationDescriptor.m_B = -1.0f; - FuseActivationIntoPreviousLayerTest < DepthwiseConvolution2dTest < DataType::Float32 > , DataType::Float32 > - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + FuseActivationIntoPreviousLayerTest < DWConvolution2dTest < DataType::Float32 > , DataType::Float32 > + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32CpuAccTest) { @@ -466,7 +548,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32CpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32CpuAccTest) { @@ -476,7 +558,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32CpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } // ReLU fused into Receiver Layers QAsymmU8 @@ -486,15 +568,15 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoConvQAsymmU8CpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvQAsymmU8CpuAccTest) { ActivationDescriptor activationDescriptor; activationDescriptor.m_Function = ActivationFunction::ReLu; - FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> + (activationDescriptor, 0.0001f, Compute::CpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedQAsymmU8CpuAccTest) { @@ -502,7 +584,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedQAsymmU8CpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } // HardSwish fused into Receiver Layers Float32 @@ -512,7 +594,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoConvFloat32CpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); } // TanH fused into Receiver Layers Float32 @@ -522,7 +604,91 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoConvFloat32CpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::CpuAcc); + (activationDescriptor, 0.0001f, Compute::CpuAcc); +} + +// Test that all receiver layers follow by all activation layers work, either fused or not fused +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationFloat32CpuAccTest) +{ + ActivationDescriptor activationDescriptor; + for (int i = 0; i != 12; ++i) + { + activationDescriptor.m_Function = static_cast(i); + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::CpuAcc)), "Convolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::CpuAcc)), "DepthwiseConvolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::CpuAcc)), "FullyConnected + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::CpuAcc)), "BatchNorm + Activation function " << i); + } +} +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationFloat16CpuAccTest) +{ + ActivationDescriptor activationDescriptor; + for (int i = 0; i != 12; ++i) + { + activationDescriptor.m_Function = static_cast(i); + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::CpuAcc)), "Convolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::CpuAcc)), "DepthwiseConvolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::CpuAcc)), "FullyConnected + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::CpuAcc)), "BatchNorm + Activation function " << i); + } +} +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationQAsymmU8CpuAccTest) +{ + ActivationDescriptor activationDescriptor; + + activationDescriptor.m_Function = ActivationFunction::Sigmoid; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc, 1.f / 256.f, 0)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc, 1.f / 256.f, 0)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::TanH; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc, 1.f / 128.f, 128)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc, 1.f / 128.f, 128)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::ReLu; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::BoundedReLu; + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::HardSwish; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::CpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); } #endif @@ -534,15 +700,15 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoConvFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoDWConvFloat32GpuAccTest) { ActivationDescriptor activationDescriptor; activationDescriptor.m_Function = ActivationFunction::ReLu; - FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + FuseActivationIntoPreviousLayerTest, DataType::Float32> + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32GpuAccTest) { @@ -550,7 +716,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoFullyConnectedFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32GpuAccTest) { @@ -558,7 +724,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoBatchNormFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoMulFloat32GpuAccTest) { @@ -566,7 +732,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoMulFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoAddFloat32GpuAccTest) { @@ -574,7 +740,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoAddFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoSubFloat32GpuAccTest) { @@ -582,7 +748,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoSubFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUIntoDivFloat32GpuAccTest) { @@ -590,7 +756,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUIntoDivFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } // BoundedReLu fused into Receiver Layers Float32 @@ -602,7 +768,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoConvFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32GpuAccTest) { @@ -611,8 +777,8 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDWConvFloat32GpuAccTest) activationDescriptor.m_A = 1.0f; activationDescriptor.m_B = -1.0f; - FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + FuseActivationIntoPreviousLayerTest, DataType::Float32> + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32GpuAccTest) { @@ -622,7 +788,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoFullyConnectedFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32GpuAccTest) { @@ -632,7 +798,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoBatchNormFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoMulFloat32GpuAccTest) { @@ -642,7 +808,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoMulFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoAddFloat32GpuAccTest) { @@ -652,7 +818,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoAddFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoSubFloat32GpuAccTest) { @@ -662,7 +828,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoSubFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDivFloat32GpuAccTest) { @@ -672,7 +838,7 @@ BOOST_AUTO_TEST_CASE(FuseBoundedReLUIntoDivFloat32GpuAccTest) activationDescriptor.m_B = -1.0f; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } // ReLU fused into Receiver Layers QAsymmU8 @@ -682,15 +848,15 @@ BOOST_AUTO_TEST_CASE(FuseReLUQIntoConvAsymmU8GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUQIntoDWConvAsymmU8GpuAccTest) { ActivationDescriptor activationDescriptor; activationDescriptor.m_Function = ActivationFunction::ReLu; - FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseReLUQIntoFullyConnectedAsymmU8GpuAccTest) { @@ -698,7 +864,7 @@ BOOST_AUTO_TEST_CASE(FuseReLUQIntoFullyConnectedAsymmU8GpuAccTest) activationDescriptor.m_Function = ActivationFunction::ReLu; FuseActivationIntoPreviousLayerTest, DataType::QAsymmU8> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } // HardSwish fused into Receiver Layers Float32 @@ -708,7 +874,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoConvFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseHardSwishIntoMulFloat32GpuAccTest) { @@ -716,7 +882,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoMulFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseHardSwishIntoAddFloat32GpuAccTest) { @@ -724,7 +890,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoAddFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseHardSwishIntoSubFloat32GpuAccTest) { @@ -732,7 +898,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoSubFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseHardSwishIntoDivFloat32GpuAccTest) { @@ -740,7 +906,7 @@ BOOST_AUTO_TEST_CASE(FuseHardSwishIntoDivFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::HardSwish; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } // TanH fused into Receiver Layers Float32 @@ -750,7 +916,7 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoConvFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseTanHIntoMulFloat32GpuAccTest) { @@ -758,7 +924,7 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoMulFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseTanHIntoAddFloat32GpuAccTest) { @@ -766,7 +932,7 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoAddFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseTanHIntoSubFloat32GpuAccTest) { @@ -774,7 +940,7 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoSubFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); } BOOST_AUTO_TEST_CASE(FuseTanHIntoDivFloat32GpuAccTest) { @@ -782,7 +948,113 @@ BOOST_AUTO_TEST_CASE(FuseTanHIntoDivFloat32GpuAccTest) activationDescriptor.m_Function = ActivationFunction::TanH; FuseActivationIntoPreviousLayerTest, DataType::Float32> - (activationDescriptor, 0.0001f, armnn::Compute::GpuAcc); + (activationDescriptor, 0.0001f, Compute::GpuAcc); +} + +// Test that all receiver layers follow by all activation layers work, either fused or not fused +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationFloat32GpuAccTest) +{ + ActivationDescriptor activationDescriptor; + for (int i = 0; i != 12; ++i) + { + activationDescriptor.m_Function = static_cast(i); + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + if (activationDescriptor.m_Function != ActivationFunction::Elu) + { + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "Convolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "DepthwiseConvolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "FullyConnected + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "BatchNorm + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "Multiplication + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "Addition + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "Subtraction + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float32> + (activationDescriptor, Compute::GpuAcc)), "Division + Activation function " << i); + } + } +} +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationFloat16GpuAccTest) +{ + ActivationDescriptor activationDescriptor; + for (int i = 0; i != 12; ++i) + { + activationDescriptor.m_Function = static_cast(i); + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + if (activationDescriptor.m_Function != ActivationFunction::Elu) + { + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Convolution + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Depthwise + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "FullyConnected + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "BatchNorm + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Multiplication + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Addition + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Subtraction + Activation function " << i); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::Float16> + (activationDescriptor, Compute::GpuAcc)), "Division + Activation function " << i); + } + } +} +BOOST_AUTO_TEST_CASE(LayerFollowedByActivationQAsymmU8GpuAccTest) +{ + ActivationDescriptor activationDescriptor; + + activationDescriptor.m_Function = ActivationFunction::Sigmoid; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc, 1.f / 256.f, 0)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc, 1.f / 256.f, 0)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::TanH; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc, 1.f / 128.f, 128)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc, 1.f / 128.f, 128)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::ReLu; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::BoundedReLu; + activationDescriptor.m_A = 1.0f; + activationDescriptor.m_B = -1.0f; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); + + activationDescriptor.m_Function = ActivationFunction::HardSwish; + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "Convolution + Activation function " << + static_cast(activationDescriptor.m_Function)); + BOOST_CHECK_MESSAGE((FuseActivationSimpleTest, DataType::QAsymmU8> + (activationDescriptor, Compute::GpuAcc)), "FullyConnected + Activation function " << + static_cast(activationDescriptor.m_Function)); } #endif -- cgit v1.2.1