Compute Library
 21.02
DepthConcatenateLayer.cpp
Go to the documentation of this file.
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 
27 
28 namespace arm_compute
29 {
30 namespace test
31 {
32 namespace validation
33 {
34 namespace reference
35 {
36 template <typename T>
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 
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
float dequantize_qasymm8(uint8_t value, const INFO_TYPE &qinfo)
Dequantize a value given an unsigned 8-bit asymmetric quantization scheme.
SimpleTensor< float > b
Definition: DFT.cpp:157
uint8_t quantize_qasymm8(float value, const INFO_TYPE &qinfo, RoundingPolicy rounding_policy=RoundingPolicy::TO_NEAREST_UP)
Quantize a value given an unsigned 8-bit asymmetric quantization scheme.
unsigned int batches
SimpleTensor< T > depthconcatenate_layer(const std::vector< SimpleTensor< T >> &srcs, SimpleTensor< T > &dst)
#define ARM_COMPUTE_ERROR_ON(cond)
If the condition is true then an error message is printed and an exception thrown.
Definition: Error.h:466
Quantization info when assuming per layer quantization.
TensorShape shape() const override
Shape of the tensor.
Definition: SimpleTensor.h:320
SimpleTensor< T > copy(const SimpleTensor< T > &src, const TensorShape &output_shape)
Definition: Copy.cpp:37
SimpleTensor< float > src
Definition: DFT.cpp:155
Copyright (c) 2017-2021 Arm Limited.
const DataType data_type
Definition: Im2Col.cpp:150
quantized, asymmetric fixed-point 8-bit number unsigned
Coordinates of an item.
Definition: Coordinates.h:37
Simple tensor object that stores elements in a consecutive chunk of memory.
Definition: SimpleTensor.h:58
int num_elements() const override
Number of elements of the tensor.
Definition: SimpleTensor.h:406
QuantizationInfo quantization_info() const override
Quantization info in case of asymmetric quantized type.
Definition: SimpleTensor.h:332
SimpleTensor< T > slice(const SimpleTensor< T > &src, Coordinates starts, Coordinates ends)
const T * data() const
Constant pointer to the underlying buffer.
Definition: SimpleTensor.h:418