blob: 0e70223998694cb4ab751a280cce80511977decc [file] [log] [blame]
Gian Marco05288a22017-11-21 10:57:50 +00001/*
Manuel Bottini9c9b70b2019-07-01 17:35:56 +01002 * Copyright (c) 2017-2019 ARM Limited.
Gian Marco05288a22017-11-21 10:57:50 +00003 *
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#ifndef __ARM_COMPUTE_CLGEMMLOWPOUTPUTSTAGE_H__
25#define __ARM_COMPUTE_CLGEMMLOWPOUTPUTSTAGE_H__
26
27#include "arm_compute/runtime/CL/ICLSimpleFunction.h"
28
29/** This file contains all available output stages for GEMMLowp on OpenCL.
30 *
31 * In gemmlowp, the "output stage" is the process that takes a final int32 accumulator value (the output of @ref CLGEMMLowpMatrixMultiplyCore),
32 * and processes it to obtain the final ASYMM8 value.
33 *
34 * More information about the GEMMLowp output stage can be found at https://github.com/google/gemmlowp/blob/master/doc/output.md
35 */
36
37namespace arm_compute
38{
39class ITensor;
40
41/** Basic function to execute CLGEMMLowpQuantizeDownInt32ToUint8Scale on OpenCL.
42 *
43 * CLGEMMLowpQuantizeDownInt32ToUint8Scale depends on 3 parameters: result_offset, result_mult_int, result_shift
44 * The final result is:
45 *
46 * ((input[i][k] + result_offset) * result_mult_int) >> result_shift
47 *
48 * In case the bias tensor is provided, the final result is:
49 *
Gian Marco58c57942017-11-28 09:10:03 +000050 * ((input[i][k] + bias[k] + result_offset) * result_mult_int) >> result_shift
Gian Marco05288a22017-11-21 10:57:50 +000051 *
52 * This function calls the following OpenCL kernels:
53 *
54 * -# @ref CLGEMMLowpQuantizeDownInt32ToUint8ScaleKernel
55 *
56 * @note The function accepts also 2 optional input arguments (min and max) which can be used to implement "rectified linear unit" activation functions
Gian Marco58c57942017-11-28 09:10:03 +000057 * after the result is shifted right by result_shift
Gian Marco05288a22017-11-21 10:57:50 +000058*/
59class CLGEMMLowpQuantizeDownInt32ToUint8Scale : public ICLSimpleFunction
60{
61public:
62 /** Initialise the kernel's inputs, output
63 *
64 * @param[in] input Input tensor. It is the output of @ref CLGEMMLowpMatrixMultiplyCore function. Data type supported: S32
65 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the addition of biases is not required.
66 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
67 * @param[out] output Output tensor. Data type supported: Data type supported: QASYMM8
68 * @param[in] result_offset Offset to be added to each element of the input matrix
69 * @param[in] result_mult_int Value to be multiplied to each element of the input matrix when once the result_offset has been add
70 * @param[in] result_shift Number of bits to shift right the result before converting back to QASYMM8
71 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
72 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
73 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
74 */
75 void configure(const ICLTensor *input, const ICLTensor *bias, ICLTensor *output, int result_offset, int result_mult_int, int result_shift, int min = 0, int max = 0);
Gian Marco58c57942017-11-28 09:10:03 +000076 /** Static function to check if given info will lead to a valid configuration of @ref CLGEMMLowpQuantizeDownInt32ToUint8Scale
77 *
78 * @param[in] input Input tensor. It is the output of @ref CLGEMMLowpMatrixMultiplyCore function. Data type supported: S32
79 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the addition of biases is not required.
80 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
81 * @param[in] output Output tensor. Data type supported: Data type supported: QASYMM8
82 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
83 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
84 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
85 *
Georgios Pinitas631c41a2017-12-06 11:53:03 +000086 * @return a status
Gian Marco58c57942017-11-28 09:10:03 +000087 */
Georgios Pinitas631c41a2017-12-06 11:53:03 +000088 static Status validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output, int min = 0, int max = 0);
Gian Marco58c57942017-11-28 09:10:03 +000089};
90
91/** Basic function to execute CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint on OpenCL.
92 *
93 * CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint depends on 3 parameters:
94 *
95 * result_fixedpoint_multiplier, result_shift, result_offset_after_shift
96 *
97 * The final result is:
98 *
99 * (FixedPointMul(input[i][k], result_fixedpoint_multiplier) >> result_shift) + result_offset_after_shift
100 *
101 * where FixedPointMul(x, y) is the nearest integer to the following
102 * mathematical expression, evaluated without overflow or intermediate rounding:
103 *
104 * (x * y) / 2^31
105 *
106 * For more information: https://github.com/google/gemmlowp/blob/master/public/output_stages.h#L68
107 *
108 * In case the bias tensor is provided, the final result is:
109 *
110 * ((FixedPointMul(input[i][k] + bias[k], result_fixedpoint_multiplier)) >> result_shift) + result_offset_after_shift
111 *
112 * This function calls the following OpenCL kernels:
113 *
114 * -# @ref CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPointKernel
115 *
116 * @note The function accepts also 2 optional input arguments (min and max) which can be used to implement "rectified linear unit" activation functions
117 * after the result is shifted right by result_shift
118*/
119class CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint : public ICLSimpleFunction
120{
121public:
122 /** Initialise the kernel's inputs, output
123 *
124 * @param[in] input Input tensor. Data type supported: S32
125 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the biases addition is not required.
126 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
127 * @param[out] output Output tensor. Data type supported: Data type supported: QASYMM8
128 * @param[in] result_fixedpoint_multiplier Fixed point value to be multiplied to each element of the input matrix when once the result_offset has been add
129 * @param[in] result_shift Number of bits to shift right the result after the fixed point multiplication
130 * @param[in] result_offset_after_shift Offset to be applied to result before converting it back to QASYMM8
131 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
132 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
133 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
134 */
Georgios Pinitas932491f2018-09-21 16:33:15 +0100135 void configure(const ICLTensor *input, const ICLTensor *bias, ICLTensor *output, int result_fixedpoint_multiplier, int result_shift, int result_offset_after_shift,
Gian Marco Iodice4b908652018-10-18 10:21:02 +0100136 int min = 0, int max = 0);
Gian Marco58c57942017-11-28 09:10:03 +0000137 /** Static function to check if given info will lead to a valid configuration of @ref CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint
138 *
Gian Marco Iodice4b908652018-10-18 10:21:02 +0100139 * @param[in] input Input tensor. It is the output of @ref CLGEMMLowpMatrixMultiplyCore function. Data type supported: S32
140 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the addition of biases is not required.
141 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
142 * @param[in] output Output tensor. Data type supported: Data type supported: QASYMM8
143 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
144 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
Georgios Pinitas932491f2018-09-21 16:33:15 +0100145 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
Gian Marco58c57942017-11-28 09:10:03 +0000146 *
Georgios Pinitas631c41a2017-12-06 11:53:03 +0000147 * @return a status
Gian Marco58c57942017-11-28 09:10:03 +0000148 */
Gian Marco Iodice4b908652018-10-18 10:21:02 +0100149 static Status validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output, int min = 0, int max = 0);
Gian Marco05288a22017-11-21 10:57:50 +0000150};
Georgios Pinitas51e53a32018-10-22 13:49:08 +0100151
152/** Basic function to execute CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFloat on OpenCL.
153 *
154 * This function calls the following OpenCL kernels:
155 *
156 * -# @ref CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFloatKernel
157 *
158 * @note The function accepts also 2 optional input arguments (min and max) which can be used to implement "rectified linear unit" activation functions
159 * after the result is shifted right by result_shift
160*/
161class CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFloat : public ICLSimpleFunction
162{
163public:
164 /** Initialise the kernel's inputs, output
165 *
Gian Marco Iodice0c54a622018-10-30 12:20:03 +0000166 * @param[in] input Input tensor. Data type supported: S32
167 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the biases addition is not required.
168 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
169 * @param[out] output Output tensor. Data type supported: Data type supported: QASYMM8
170 * @param[in] multiplier Float multiplier to be multiplied to each element of the input matrix
171 * @param[in] offset Offset to be applied to result before converting it back to QASYMM8
172 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
173 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
174 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
Georgios Pinitas51e53a32018-10-22 13:49:08 +0100175 */
Gian Marco Iodice0c54a622018-10-30 12:20:03 +0000176 void configure(const ICLTensor *input, const ICLTensor *bias, ICLTensor *output, float multiplier, int offset, int min = 0, int max = 0);
Georgios Pinitas51e53a32018-10-22 13:49:08 +0100177 /** Static function to check if given info will lead to a valid configuration of @ref CLGEMMLowpQuantizeDownInt32ToUint8ScaleByFixedPoint
178 *
Gian Marco Iodice0c54a622018-10-30 12:20:03 +0000179 * @param[in] input Input tensor. It is the output of @ref CLGEMMLowpMatrixMultiplyCore function. Data type supported: S32
180 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the addition of biases is not required.
181 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
182 * @param[in] output Output tensor. Data type supported: Data type supported: QASYMM8
183 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QASYMM8
184 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QASYMM8,
185 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions
Georgios Pinitas51e53a32018-10-22 13:49:08 +0100186 *
187 * @return a status
188 */
Gian Marco Iodice0c54a622018-10-30 12:20:03 +0000189 static Status validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output, int min = 0, int max = 0);
Georgios Pinitas51e53a32018-10-22 13:49:08 +0100190};
Manuel Bottini9c9b70b2019-07-01 17:35:56 +0100191/** Basic function to execute CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint on OpenCL.
192 *
193 * CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint depends on 2 parameters:
194 *
195 * result_fixedpoint_multiplier, result_shift
196 *
197 * The final result is:
198 *
199 * (FixedPointMul(input[i][k], result_fixedpoint_multiplier) >> result_shift)
200 *
201 * where FixedPointMul(x, y) is the nearest integer to the following
202 * mathematical expression, evaluated without overflow or intermediate rounding:
203 *
204 * (x * y) / 2^31
205 *
206 * For more information: https://github.com/google/gemmlowp/blob/master/public/output_stages.h#L68
207 *
208 * In case the bias tensor is provided, the final result is:
209 *
210 * ((FixedPointMul(input[i][k] + bias[k], result_fixedpoint_multiplier)) >> result_shift) + result_offset_after_shift
211 *
212 * This function calls the following NEON kernels:
213 *
214 * -# @ref CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPointKernel
215 *
216 * @note The function accepts also 2 optional input arguments (min and max) which can be used to implement "rectified linear unit" activation functions
217 * after the result is shifted right by result_shift
218*/
219class CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint : public ICLSimpleFunction
220{
221public:
222 /** Initialise the kernel's inputs, output
223 *
224 * @param[in] input Input tensor. Data type supported: S32
225 * @param[in] bias Biases tensor. Only shared biases supported and it can be a nullptr if the biases addition is not required.
226 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
227 * @param[out] output Output tensor. Data type supported: Data type supported: QSYMM16
228 * @param[in] result_fixedpoint_multiplier Fixed point value to be multiplied to each element of the input matrix when once the result_offset has been add
229 * @param[in] result_shift Number of bits to shift right the result after the fixed point multiplication
230 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QSYMM16. Defaults to 0.
231 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QSYMM16.
232 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions. Defaults to 0.
233 */
234 void configure(const ICLTensor *input, const ICLTensor *bias, ICLTensor *output, int result_fixedpoint_multiplier, int result_shift, int min = 0, int max = 0);
235 /** Static function to check if given info will lead to a valid configuration of @ref CLGEMMLowpQuantizeDownInt32ToInt16ScaleByFixedPoint
236 *
237 * @param[in] input Input tensor info. It is the output of @ref CLGEMMLowpMatrixMultiplyCore function. Data type supported: S32
238 * @param[in] bias Biases tensor info. Only shared biases supported and it can be a nullptr if the addition of biases is not required.
239 * Biases are 1D tensor with dimensions [OFM]. Data type supported: Same as @p input.
240 * @param[in] output Output tensor info. Data type supported: Data type supported: QSYMM16
241 * @param[in] min (Optional) Min value used to saturate down the output result before converting back to QSYMM16. Defaults to 0.
242 * @param[in] max (Optional) Max value used to saturate up the output result before converting back to QSYMM16,
243 * Along with @p min, this value can be used to implement "rectified linear unit" activation functions. Defaults to 0.
244 *
245 * @return a status
246 */
247 static Status validate(const ITensorInfo *input, const ITensorInfo *bias, const ITensorInfo *output, int min = 0, int max = 0);
248};
Georgios Pinitas932491f2018-09-21 16:33:15 +0100249} // namespace arm_compute
Gian Marco05288a22017-11-21 10:57:50 +0000250#endif /*__ARM_COMPUTE_CLGEMMLOWPOUTPUTSTAGE_H__ */