/* * Copyright (c) 2022-2024 Arm Limited. * * SPDX-License-Identifier: MIT * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in all * copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE * SOFTWARE. */ #include "arm_compute/core/CL/CLKernelLibrary.h" #include "arm_compute/core/QuantizationInfo.h" #include "arm_compute/core/TensorInfo.h" #include "arm_compute/core/Types.h" #include "arm_compute/dynamic_fusion/runtime/gpu/cl/ClWorkloadRuntime.h" #include "arm_compute/dynamic_fusion/sketch/attributes/CastAttributes.h" #include "arm_compute/dynamic_fusion/sketch/attributes/Conv2dAttributes.h" #include "arm_compute/dynamic_fusion/sketch/attributes/DepthwiseConv2dAttributes.h" #include "arm_compute/dynamic_fusion/sketch/gpu/GpuWorkloadSketch.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuAdd.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuCast.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuConv2d.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuDepthwiseConv2d.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuMul.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuOutput.h" #include "arm_compute/dynamic_fusion/sketch/gpu/operators/GpuSigmoid.h" #include "tests/CL/CLAccessor.h" #include "tests/framework/Macros.h" #include "tests/validation/dynamic_fusion/Utils.h" #include "tests/validation/reference/ActivationLayer.h" #include "tests/validation/reference/ConvolutionLayer.h" #include "tests/validation/reference/DepthConvertLayer.h" #include "tests/validation/reference/DepthwiseConvolutionLayer.h" #include "tests/validation/reference/ElementwiseOperations.h" #include "tests/validation/reference/Permute.h" #include "tests/validation/reference/PixelWiseMultiplication.h" #include "tests/validation/Validation.h" using namespace arm_compute::experimental::dynamic_fusion; using namespace arm_compute::test::validation::utils; namespace arm_compute { namespace test { namespace validation { TEST_SUITE(CL) TEST_SUITE(INTEGRATION) TEST_SUITE(DYNAMIC_FUSION) TEST_CASE(Conv2d, framework::DatasetMode::ALL) { /* Computation: * out = conv2d1x1(direct_conv)(input, weights, bias) */ CLScheduler::get().default_reinit(); const auto data_type = DataType::F32; const auto data_layout = DataLayout::NHWC; const auto t_input_shape = TensorShape(384, 12, 12); const auto t_weight_shape = TensorShape(384, 1, 1, 16); const auto t_dst_shape = TensorShape(16, 12, 12); // Create a new workload sketch auto cl_compile_ctx = CLKernelLibrary::get().get_compile_context(); auto context = GpuWorkloadContext{&cl_compile_ctx}; GpuWorkloadSketch sketch{&context}; // Fuse conv2d Conv2dAttributes conv2d_attr{}; ITensorInfo *input_info = context.create_tensor_info(t_input_shape, 1, data_type, data_layout); ITensorInfo *weight_info = context.create_tensor_info(TensorInfo(t_weight_shape, 1, data_type, data_layout)); ITensorInfo *conv_out_info = GpuConv2d::create_op(sketch, input_info, weight_info, nullptr, conv2d_attr); ITensorInfo *dst_info = context.create_tensor_info(); GpuOutput::create_op(sketch, conv_out_info, dst_info); // Configure runtime ClWorkloadRuntime runtime; runtime.configure(sketch); // (Important) Allocate auxiliary tensor memory if there are any // Instead of using ACL allocated memory, the user can choose to import memory into the tensors for (auto &data : runtime.get_auxiliary_tensors()) { CLTensor *tensor = std::get<0>(data); TensorInfo info = std::get<1>(data); AuxMemoryInfo aux_mem_req = std::get<2>(data); tensor->allocator()->init(info, aux_mem_req.alignment); tensor->allocator()->allocate(); // Use ACL allocated memory // auto buf = cl::Buffer(); // tensor->allocator()->import_memory(buf); // Or, import external memory } // Construct user tensors CLTensor t_input{}; CLTensor t_weight{}; CLTensor t_dst{}; // Initialize user tensors t_input.allocator()->init(*input_info); t_weight.allocator()->init(*weight_info); t_dst.allocator()->init(*dst_info); // Allocate and fill user tensors // Instead of using ACL allocator, the user can choose to import memory into the tensors t_input.allocator()->allocate(); t_weight.allocator()->allocate(); t_dst.allocator()->allocate(); fill(CLAccessor(t_input), 0, library.get()); fill(CLAccessor(t_weight), 1, library.get()); // Run runtime runtime.run({&t_input, &t_weight, &t_dst}); // Create reference SimpleTensor ref_t_input{t_input_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC}; SimpleTensor ref_t_weight{t_weight_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC}; SimpleTensor ref_t_bias_placeholder{t_dst_shape, data_type, 1, QuantizationInfo(), DataLayout::NHWC}; // Fill reference fill(ref_t_input, 0, library.get()); fill(ref_t_weight, 1, library.get()); auto ref_t_input_nchw = reference::permute(ref_t_input, PermutationVector(1U, 2U, 0U)); auto ref_t_weight_nchw = reference::permute(ref_t_weight, PermutationVector(1U, 2U, 0U)); auto ref_t_bias_placeholder_nchw = reference::permute(ref_t_bias_placeholder, PermutationVector(1U, 2U, 0U)); auto t_dst_shape_nchw = t_dst_shape; permute(t_dst_shape_nchw, PermutationVector(1U, 2U, 0U)); PadStrideInfo legacy_pad_stride(conv2d_attr.stride().x(), conv2d_attr.stride().y(), conv2d_attr.pad().left, conv2d_attr.pad().right, conv2d_attr.pad().top, conv2d_attr.pad().bottom, DimensionRoundingType{}); auto ref_t_dst_nchw = reference::convolution_layer(ref_t_input_nchw, ref_t_weight_nchw, ref_t_bias_placeholder_nchw, t_dst_shape_nchw, legacy_pad_stride, conv2d_attr.dilation()); const auto ref_t_dst = reference::permute(ref_t_dst_nchw, PermutationVector(2U, 0U, 1U)); RelativeTolerance tolerance_f32( 0.001f); /**< Tolerance value for comparing reference's output against implementation's output for floating point data types */ validate(CLAccessor(t_dst), ref_t_dst_nchw, tolerance_f32); } TEST_CASE(Add_Output_Add_Output, framework::DatasetMode::ALL) { /* Computation: * out_0 = in_0 + in_1 * out_1 = out_0 + in_2 */ CLScheduler::get().default_reinit(); const auto data_type = DataType::F32; const auto t_input_shape = TensorShape(33, 3, 2); // Create a new workload sketch auto cl_compile_ctx = CLKernelLibrary::get().get_compile_context(); auto context = GpuWorkloadContext{&cl_compile_ctx}; GpuWorkloadSketch sketch{&context}; ITensorInfo *in_0_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *in_1_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *in_2_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *out_0_info = context.create_tensor_info(); ITensorInfo *out_1_info = context.create_tensor_info(); ITensorInfo *ans_0_info = GpuAdd::create_op(sketch, in_0_info, in_1_info); GpuOutput::create_op(sketch, ans_0_info, out_0_info); ITensorInfo *ans_1_info = GpuAdd::create_op(sketch, ans_0_info, in_2_info); GpuOutput::create_op(sketch, ans_1_info, out_1_info); // Configure runtime ClWorkloadRuntime runtime; runtime.configure(sketch); // (Important) Allocate auxiliary tensor memory if there are any // Instead of using ACL allocated memory, the user can choose to import memory into the tensors for (auto &data : runtime.get_auxiliary_tensors()) { CLTensor *tensor = std::get<0>(data); TensorInfo info = std::get<1>(data); AuxMemoryInfo aux_mem_req = std::get<2>(data); tensor->allocator()->init(info, aux_mem_req.alignment); tensor->allocator()->allocate(); // Use ACL allocated memory // auto buf = cl::Buffer(); // tensor->allocator()->import_memory(buf); // Or, import external memory } // Construct user tensors CLTensor t_in_0{}; CLTensor t_in_1{}; CLTensor t_in_2{}; CLTensor t_out_0{}; CLTensor t_out_1{}; // Initialize user tensors t_in_0.allocator()->init(*in_0_info); t_in_1.allocator()->init(*in_1_info); t_in_2.allocator()->init(*in_2_info); t_out_0.allocator()->init(*out_0_info); t_out_1.allocator()->init(*out_1_info); // Allocate and fill user tensors // Instead of using ACL allocator, the user can choose to import memory into the tensors t_in_0.allocator()->allocate(); t_in_1.allocator()->allocate(); t_in_2.allocator()->allocate(); t_out_0.allocator()->allocate(); t_out_1.allocator()->allocate(); fill(CLAccessor(t_in_0), 0, library.get()); fill(CLAccessor(t_in_1), 1, library.get()); fill(CLAccessor(t_in_2), 2, library.get()); // Run runtime runtime.run({&t_in_0, &t_in_1, &t_in_2, &t_out_0, &t_out_1}); // Create reference SimpleTensor ref_t_in_0{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_in_1{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_in_2{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_out_0{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_out_1{t_input_shape, data_type, 1, QuantizationInfo()}; // Fill reference fill(ref_t_in_0, 0, library.get()); fill(ref_t_in_1, 1, library.get()); fill(ref_t_in_2, 2, library.get()); reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_in_0, ref_t_in_1, ref_t_out_0, ConvertPolicy::WRAP); reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_out_0, ref_t_in_2, ref_t_out_1, ConvertPolicy::WRAP); RelativeTolerance tolerance_f32( 0.001f); /**< Tolerance value for comparing reference's output against implementation's output for floating point data types */ validate(CLAccessor(t_out_0), ref_t_out_0, tolerance_f32); validate(CLAccessor(t_out_1), ref_t_out_1, tolerance_f32); } TEST_CASE(Add_Output_Add_Cast_Cast_Output, framework::DatasetMode::ALL) { /* Computation: * out_0 = in_0 + in_1 * out_1 = float(int32_t(out_0 + in_2)) */ CLScheduler::get().default_reinit(); const auto data_type = DataType::F32; const auto t_input_shape = TensorShape(3, 8, 5); // Create a new workload sketch auto cl_compile_ctx = CLKernelLibrary::get().get_compile_context(); auto context = GpuWorkloadContext{&cl_compile_ctx}; GpuWorkloadSketch sketch{&context}; ITensorInfo *in_0_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *in_1_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *in_2_info = context.create_tensor_info(t_input_shape, 1, data_type); ITensorInfo *out_0_info = context.create_tensor_info(); ITensorInfo *out_1_info = context.create_tensor_info(); CastAttributes cast_0_attr; cast_0_attr.data_type(DataType::F16); CastAttributes cast_1_attr; cast_1_attr.data_type(DataType::F32); ITensorInfo *ans_0_info = GpuAdd::create_op(sketch, in_0_info, in_1_info); GpuOutput::create_op(sketch, ans_0_info, out_0_info); ITensorInfo *ans_1_info = GpuAdd::create_op(sketch, ans_0_info, in_2_info); ITensorInfo *ans_2_info = GpuCast::create_op(sketch, ans_1_info, cast_0_attr); ITensorInfo *ans_3_info = GpuCast::create_op(sketch, ans_2_info, cast_1_attr); GpuOutput::create_op(sketch, ans_3_info, out_1_info); // Configure runtime ClWorkloadRuntime runtime; runtime.configure(sketch); // (Important) Allocate auxiliary tensor memory if there are any // Instead of using ACL allocated memory, the user can choose to import memory into the tensors for (auto &data : runtime.get_auxiliary_tensors()) { CLTensor *tensor = std::get<0>(data); TensorInfo info = std::get<1>(data); AuxMemoryInfo aux_mem_req = std::get<2>(data); tensor->allocator()->init(info, aux_mem_req.alignment); tensor->allocator()->allocate(); // Use ACL allocated memory // auto buf = cl::Buffer(); // tensor->allocator()->import_memory(buf); // Or, import external memory } // Construct user tensors CLTensor t_in_0{}; CLTensor t_in_1{}; CLTensor t_in_2{}; CLTensor t_out_0{}; CLTensor t_out_1{}; // Initialize user tensors t_in_0.allocator()->init(*in_0_info); t_in_1.allocator()->init(*in_1_info); t_in_2.allocator()->init(*in_2_info); t_out_0.allocator()->init(*out_0_info); t_out_1.allocator()->init(*out_1_info); // Allocate and fill user tensors // Instead of using ACL allocator, the user can choose to import memory into the tensors t_in_0.allocator()->allocate(); t_in_1.allocator()->allocate(); t_in_2.allocator()->allocate(); t_out_0.allocator()->allocate(); t_out_1.allocator()->allocate(); fill(CLAccessor(t_in_0), 0, library.get()); fill(CLAccessor(t_in_1), 1, library.get()); fill(CLAccessor(t_in_2), 2, library.get()); // Run runtime runtime.run({&t_in_0, &t_in_1, &t_in_2, &t_out_0, &t_out_1}); // Create reference SimpleTensor ref_t_in_0{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_in_1{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_in_2{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_out_0{t_input_shape, data_type, 1, QuantizationInfo()}; SimpleTensor ref_t_ans_1{t_input_shape, data_type, 1, QuantizationInfo()}; // Fill reference fill(ref_t_in_0, 0, library.get()); fill(ref_t_in_1, 1, library.get()); fill(ref_t_in_2, 2, library.get()); reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_in_0, ref_t_in_1, ref_t_out_0, ConvertPolicy::WRAP); reference::arithmetic_operation(ArithmeticOperation::ADD, ref_t_out_0, ref_t_in_2, ref_t_ans_1, ConvertPolicy::WRAP); const auto ref_t_ans_2 = reference::depth_convert(ref_t_ans_1, DataType::S32, ConvertPolicy::SATURATE, 0); const auto ref_t_out_1 = reference::depth_convert(ref_t_ans_2, DataType::F32, ConvertPolicy::SATURATE, 0); RelativeTolerance tolerance_add_f32(0.001f); AbsoluteTolerance tolerance_cast_f32(1.0f); validate(CLAccessor(t_out_0), ref_t_out_0, tolerance_add_f32); validate(CLAccessor(t_out_1), ref_t_out_1, tolerance_cast_f32); } /// TODO: COMPMID-6593 : This integration test fails with CKW backend. /// It was not enabled for CKW before, therefore went unnoticed. TEST_CASE(Conv2d_Sigmoid_DepthwiseConv2d_Mul, framework::DatasetMode::DISABLED) { // (tensor0) // | // ======|============================================== Sketch 0 // | (tensor1) +---- (tensor2) // | | | | // +-- input -- weights -- biases --+ | // | | | // | Conv2d | | // | | | // +----------- output -------------+ | // | | // +-- input ---+ | // | | | // | Sigmoid | | // | | | // +-- output --+ | // | | // +-- input ---+ | // | | | // | Output | | // | | | // +-- output --+ | // | | // (tensor5) | // | | // +--------+ | // ======|=============================|================ Sketch 1 // | (tensor3) (tensor4) | // | | | | // +-- input -- weights -- biases --+ | // | | | // | DepthwiseConv2d | | // | | | // +----------- output -------------+ | // | | // +--+ +----------------+ // | | // +-- lhs -- rhs --+ // | | // | Multiply | // | | // +---- output ----+ // | // +-- input ---+ // | | // | Output | // | | // +-- output --+ // | // (tensor6) TensorShape conv2d_src_shape(10, 20, 30); TensorShape conv2d_wei_shape(10, 3, 3, 5); TensorShape conv2d_bia_shape(5); TensorShape conv2d_dst_shape(5, 18, 28); TensorShape dwc_wei_shape(5, 3, 3); TensorShape dwc_bia_shape(5); TensorShape dwc_dst_shape(5, 16, 26); // Initialize the context. CLScheduler::get().default_reinit(); auto cl_compile_ctx = CLKernelLibrary::get().get_compile_context(); GpuWorkloadContext context(&cl_compile_ctx); auto tensor0_info = context.create_tensor_info(conv2d_src_shape, 1, DataType::F32, DataLayout::NHWC); // Create the first sketch: conv2d + cast + output. GpuWorkloadSketch sketch0(&context); Conv2dAttributes conv2d_attr; auto tensor1_info = context.create_tensor_info(conv2d_wei_shape, 1, DataType::F32, DataLayout::NHWC); auto tensor2_info = context.create_tensor_info(conv2d_bia_shape, 1, DataType::F32, DataLayout::NHWC); ARM_COMPUTE_EXPECT(GpuConv2d::validate_op(sketch0, tensor0_info, tensor1_info, tensor2_info, conv2d_attr), framework::LogLevel::ERRORS); auto ans_info = GpuConv2d::create_op(sketch0, tensor0_info, tensor1_info, tensor2_info, conv2d_attr); ARM_COMPUTE_EXPECT(GpuSigmoid::validate_op(sketch0, ans_info), framework::LogLevel::ERRORS); ans_info = GpuSigmoid::create_op(sketch0, ans_info); DepthwiseConv2dAttributes dwc_attr; auto tensor3_info = context.create_tensor_info(dwc_wei_shape, 1, DataType::F32, DataLayout::NHWC); auto tensor4_info = context.create_tensor_info(dwc_bia_shape, 1, DataType::F32, DataLayout::NHWC); ARM_COMPUTE_EXPECT(!GpuDepthwiseConv2d::validate_op(sketch0, ans_info, tensor3_info, tensor4_info, dwc_attr), framework::LogLevel::ERRORS); auto tensor5_info = context.create_tensor_info(); ARM_COMPUTE_EXPECT(GpuOutput::validate_op(sketch0, ans_info, tensor5_info), framework::LogLevel::ERRORS); GpuOutput::create_op(sketch0, ans_info, tensor5_info); // Create the first workload runtime. ClWorkloadRuntime runtime0; runtime0.configure(sketch0); // Create the second sketch: dwc + sigmoid + output. GpuWorkloadSketch sketch1(&context); ARM_COMPUTE_EXPECT(GpuDepthwiseConv2d::validate_op(sketch1, tensor5_info, tensor3_info, tensor4_info, dwc_attr), framework::LogLevel::ERRORS); ans_info = GpuDepthwiseConv2d::create_op(sketch1, tensor5_info, tensor3_info, tensor4_info, dwc_attr); ARM_COMPUTE_EXPECT(GpuMul::validate_op(sketch1, ans_info, tensor2_info), framework::LogLevel::ERRORS); ans_info = GpuMul::create_op(sketch1, ans_info, tensor2_info); auto tensor6_info = context.create_tensor_info(); ARM_COMPUTE_EXPECT(GpuOutput::validate_op(sketch1, ans_info, tensor6_info), framework::LogLevel::ERRORS); GpuOutput::create_op(sketch1, ans_info, tensor6_info); // Create the second workload runtime. ClWorkloadRuntime runtime1; runtime1.configure(sketch1); // Create the user tensors. CLTensor tensor0; CLTensor tensor1; CLTensor tensor2; CLTensor tensor3; CLTensor tensor4; CLTensor tensor5; CLTensor tensor6; tensor0.allocator()->init(*tensor0_info); tensor1.allocator()->init(*tensor1_info); tensor2.allocator()->init(*tensor2_info); tensor3.allocator()->init(*tensor3_info); tensor4.allocator()->init(*tensor4_info); tensor5.allocator()->init(*tensor5_info); tensor6.allocator()->init(*tensor6_info); tensor0.allocator()->allocate(); tensor1.allocator()->allocate(); tensor2.allocator()->allocate(); tensor3.allocator()->allocate(); tensor4.allocator()->allocate(); tensor5.allocator()->allocate(); tensor6.allocator()->allocate(); // Allocate the auxiliary tensors. for (auto &data : runtime0.get_auxiliary_tensors()) { auto tensor = std::get<0>(data); auto &tensor_info = std::get<1>(data); auto mem_req = std::get<2>(data); tensor->allocator()->init(tensor_info, mem_req.alignment); tensor->allocator()->allocate(); } for (auto &data : runtime1.get_auxiliary_tensors()) { auto tensor = std::get<0>(data); auto &tensor_info = std::get<1>(data); auto mem_req = std::get<2>(data); tensor->allocator()->init(tensor_info, mem_req.alignment); tensor->allocator()->allocate(); } // Fill the input tensors with random data. fill(CLAccessor(tensor0), 0, library.get()); fill(CLAccessor(tensor1), 1, library.get()); fill(CLAccessor(tensor2), 2, library.get()); fill(CLAccessor(tensor3), 3, library.get()); fill(CLAccessor(tensor4), 4, library.get()); // Run each runtime. runtime0.run({&tensor0, &tensor1, &tensor2, &tensor5}); runtime1.run({&tensor5, &tensor3, &tensor4, &tensor2, &tensor6}); // Compute the reference result. SimpleTensor ref_conv2d_src(conv2d_src_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC); SimpleTensor ref_conv2d_wei(conv2d_wei_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC); SimpleTensor ref_conv2d_bia(conv2d_bia_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC); SimpleTensor ref_dwc_wei(dwc_wei_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC); SimpleTensor ref_dwc_bia(dwc_bia_shape, DataType::F32, 1, QuantizationInfo(), DataLayout::NHWC); fill(ref_conv2d_src, 0, library.get()); fill(ref_conv2d_wei, 1, library.get()); fill(ref_conv2d_bia, 2, library.get()); fill(ref_dwc_wei, 3, library.get()); fill(ref_dwc_bia, 4, library.get()); PermutationVector nhwc_to_nchw(1, 2, 0); auto conv2d_dst_shape_nchw = conv2d_dst_shape; permute(conv2d_dst_shape_nchw, nhwc_to_nchw); const auto ref_conv2d_src_nchw = reference::permute(ref_conv2d_src, nhwc_to_nchw); const auto ref_conv2d_wei_nchw = reference::permute(ref_conv2d_wei, nhwc_to_nchw); const auto ref_conv2d_bia_nchw = reference::permute(ref_conv2d_bia, nhwc_to_nchw); const auto ref_conv2d_dst_nchw = reference::convolution_layer( ref_conv2d_src_nchw, ref_conv2d_wei_nchw, ref_conv2d_bia_nchw, conv2d_dst_shape_nchw, PadStrideInfo()); const auto ref_sigmoid_dst_nchw = reference::activation_layer( ref_conv2d_dst_nchw, ActivationLayerInfo(ActivationLayerInfo::ActivationFunction::LOGISTIC)); auto dwc_dst_shape_nchw = dwc_dst_shape; permute(dwc_dst_shape_nchw, nhwc_to_nchw); const auto ref_dwc_wei_nchw = reference::permute(ref_dwc_wei, nhwc_to_nchw); const auto ref_dwc_bia_nchw = reference::permute(ref_dwc_bia, nhwc_to_nchw); const auto ref_dwc_dst_nchw = reference::depthwise_convolution( ref_sigmoid_dst_nchw, ref_dwc_wei_nchw, ref_dwc_bia_nchw, dwc_dst_shape_nchw, PadStrideInfo(), 1); const auto ref_mul_dst_nchw = reference::pixel_wise_multiplication( ref_dwc_dst_nchw, ref_conv2d_bia_nchw, 1.0, ConvertPolicy::SATURATE, RoundingPolicy::TO_NEAREST_UP, DataType::F32); constexpr RelativeTolerance tolerance(0.001f); validate(CLAccessor(tensor6), ref_mul_dst_nchw, tolerance); } TEST_SUITE(Invalid_Fusion_Should_Fail) TEST_CASE(Multiple_Complex_Ops_0, framework::DatasetMode::ALL) { /* Computation: * out = conv2d(conv2d(l0_input, l0_weight), l1_weight) */ CLScheduler::get().default_reinit(); const auto data_type = DataType::F32; const auto data_layout = DataLayout::NHWC; const auto t_input_shape = TensorShape(384, 12, 12); const auto t_weight_shape = TensorShape(384, 1, 1, 16); auto t_input_info = TensorInfo(t_input_shape, 1, data_type, data_layout); auto t_weight_info = TensorInfo(t_weight_shape, 1, data_type, data_layout); auto t_dst_info = TensorInfo(); Conv2dAttributes conv2d_attr{}; // Create a new workload sketch auto cl_compile_ctx = CLKernelLibrary::get().get_compile_context(); auto context = GpuWorkloadContext{&cl_compile_ctx}; GpuWorkloadSketch sketch{&context}; // Create tensor infos ITensorInfo *input_info = context.create_tensor_info(t_input_shape, 1, data_type, data_layout); ITensorInfo *weight_info = context.create_tensor_info(TensorInfo(t_weight_shape, 1, data_type, data_layout)); ITensorInfo *dst_info; // Fuse conv2d into the workload { // Validate operator const Status success = GpuConv2d::validate_op(sketch, input_info, weight_info, nullptr, conv2d_attr); ARM_COMPUTE_EXPECT(bool(success), framework::LogLevel::ERRORS); dst_info = GpuConv2d::create_op(sketch, input_info, weight_info, nullptr, conv2d_attr); } // Create tensor infos ITensorInfo *weight_info_2 = context.create_tensor_info(t_weight_info); // Fuse conv2d into the workload { // Validate operator, should fail const Status success = GpuConv2d::validate_op(sketch, dst_info, weight_info_2, nullptr, conv2d_attr); const auto expected_error_str = "Operator fusion test failed. This operator cannot be fused into the workload"; ARM_COMPUTE_EXPECT(!bool(success), framework::LogLevel::ERRORS); ARM_COMPUTE_EXPECT((success.error_description().find(expected_error_str) != std::string::npos), framework::LogLevel::ERRORS); } } TEST_SUITE_END() // Invalid_Fusion_Should_Fail TEST_SUITE_END() // DYNAMIC_FUSION TEST_SUITE_END() // INTEGRATION TEST_SUITE_END() // CL } // namespace validation } // namespace test } // namespace arm_compute