1 /*
2 * Copyright (c) 2017-2020 Arm Limited.
3 *
4 * SPDX-License-Identifier: MIT
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to
8 * deal in the Software without restriction, including without limitation the
9 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
10 * sell copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in all
14 * copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 * SOFTWARE.
23 */
24 #include "DepthConcatenateLayer.h"
25
26 #include "tests/validation/Helpers.h"
27
28 namespace arm_compute
29 {
30 namespace test
31 {
32 namespace validation
33 {
34 namespace reference
35 {
36 template <typename T>
depthconcatenate_layer(const std::vector<SimpleTensor<T>> & srcs,SimpleTensor<T> & dst)37 SimpleTensor<T> depthconcatenate_layer(const std::vector<SimpleTensor<T>> &srcs, SimpleTensor<T> &dst)
38 {
39 // Create reference
40 std::vector<TensorShape> shapes;
41 shapes.reserve(srcs.size());
42 for(const auto &src : srcs)
43 {
44 shapes.emplace_back(src.shape());
45 }
46
47 // Compute reference
48 int depth_offset = 0;
49 const int width_out = dst.shape().x();
50 const int height_out = dst.shape().y();
51 const int depth_out = dst.shape().z();
52 const int out_stride_z = width_out * height_out;
53 const int batches = dst.shape().total_size_upper(3);
54 auto have_different_quantization_info = [&](const SimpleTensor<T> &tensor)
55 {
56 return tensor.quantization_info() != dst.quantization_info();
57 };
58
59 if(srcs[0].data_type() == DataType::QASYMM8 && std::any_of(srcs.cbegin(), srcs.cend(), have_different_quantization_info))
60 {
61 #if defined(_OPENMP)
62 #pragma omp parallel for
63 #endif /* _OPENMP */
64 for(int b = 0; b < batches; ++b)
65 {
66 // input tensors can have smaller width and height than the output, so for each output's slice we need to requantize 0 (as this is the value
67 // used in NEFillBorderKernel by NEDepthConcatenateLayer) using the corresponding quantization info for that particular slice/input tensor.
68 int slice = 0;
69 for(const auto &src : srcs)
70 {
71 auto ptr_slice = static_cast<T *>(dst(Coordinates(0, 0, slice, b)));
72 const auto num_elems_in_slice((dst.num_elements() / depth_out) * src.shape().z());
73 const UniformQuantizationInfo iq_info = src.quantization_info().uniform();
74 const UniformQuantizationInfo oq_info = dst.quantization_info().uniform();
75
76 std::transform(ptr_slice, ptr_slice + num_elems_in_slice, ptr_slice, [&](T)
77 {
78 return quantize_qasymm8(dequantize_qasymm8(0, iq_info), oq_info);
79 });
80 slice += src.shape().z();
81 }
82 }
83 }
84 else
85 {
86 std::fill_n(dst.data(), dst.num_elements(), 0);
87 }
88
89 for(const auto &src : srcs)
90 {
91 ARM_COMPUTE_ERROR_ON(depth_offset >= depth_out);
92 ARM_COMPUTE_ERROR_ON(batches != static_cast<int>(src.shape().total_size_upper(3)));
93
94 const int width = src.shape().x();
95 const int height = src.shape().y();
96 const int depth = src.shape().z();
97 const int x_diff = (width_out - width) / 2;
98 const int y_diff = (height_out - height) / 2;
99
100 const T *src_ptr = src.data();
101
102 for(int b = 0; b < batches; ++b)
103 {
104 const size_t offset_to_first_element = b * out_stride_z * depth_out + depth_offset * out_stride_z + y_diff * width_out + x_diff;
105
106 for(int d = 0; d < depth; ++d)
107 {
108 for(int r = 0; r < height; ++r)
109 {
110 if(src.data_type() == DataType::QASYMM8 && src.quantization_info() != dst.quantization_info())
111 {
112 const UniformQuantizationInfo iq_info = src.quantization_info().uniform();
113 const UniformQuantizationInfo oq_info = dst.quantization_info().uniform();
114 std::transform(src_ptr, src_ptr + width, dst.data() + offset_to_first_element + d * out_stride_z + r * width_out, [&](T t)
115 {
116 const float dequantized_input = dequantize_qasymm8(t, iq_info);
117 return quantize_qasymm8(dequantized_input, oq_info);
118 });
119 src_ptr += width;
120 }
121 else
122 {
123 std::copy(src_ptr, src_ptr + width, dst.data() + offset_to_first_element + d * out_stride_z + r * width_out);
124 src_ptr += width;
125 }
126 }
127 }
128 }
129
130 depth_offset += depth;
131 }
132
133 return dst;
134 }
135
136 template SimpleTensor<uint8_t> depthconcatenate_layer(const std::vector<SimpleTensor<uint8_t>> &srcs, SimpleTensor<uint8_t> &dst);
137 template SimpleTensor<float> depthconcatenate_layer(const std::vector<SimpleTensor<float>> &srcs, SimpleTensor<float> &dst);
138 template SimpleTensor<half> depthconcatenate_layer(const std::vector<SimpleTensor<half>> &srcs, SimpleTensor<half> &dst);
139 } // namespace reference
140 } // namespace validation
141 } // namespace test
142 } // namespace arm_compute
143