Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 1 | # Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved. |
| 2 | # |
| 3 | # SPDX-License-Identifier: Apache-2.0 |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the License); you may |
| 6 | # not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an AS IS BASIS, WITHOUT |
| 13 | # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 16 | # Description: |
| 17 | # Contains various scaling calculations for weights, elementwise operations, pooling etc. |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 18 | import math |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 19 | from enum import IntEnum |
| 20 | |
Diego Russo | ea6111a | 2020-04-14 18:41:58 +0100 | [diff] [blame] | 21 | from .numeric_util import round_away_zero |
| 22 | |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 23 | |
| 24 | class OperandToScale(IntEnum): |
| 25 | OPa = 1 |
| 26 | OPb = 2 |
| 27 | |
| 28 | |
| 29 | # Quantise floating point scale value into 32-bit int scale and 6-bit shift |
| 30 | def quantise_scale(scale): |
| 31 | significand, exponent = math.frexp(scale) |
| 32 | significand_q31 = int(round_away_zero(significand * (1 << 31))) |
| 33 | exponent_q31 = exponent - 31 |
| 34 | shift = exponent_q31 * -1 |
| 35 | |
Jacob Bohlin | 1cdc467 | 2020-08-20 15:51:37 +0200 | [diff] [blame] | 36 | if not (0 <= shift < (1 << 6)): |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 37 | # Shift outside of valid range, set scale to 0 |
| 38 | return 0, 16 |
| 39 | |
| 40 | return significand_q31, shift |
| 41 | |
| 42 | |
Fredrik Svedberg | d67c0aa | 2020-03-30 13:15:28 +0200 | [diff] [blame] | 43 | # Reduced precision quantization for int16 |
| 44 | def reduced_quantise_scale(scale): |
| 45 | multiplier, shift = quantise_scale(scale) |
Fredrik Svedberg | d2e3355 | 2020-09-01 15:42:22 +0200 | [diff] [blame] | 46 | reduced_multiplier = int((multiplier + (1 << 15)) >> 16) if multiplier < 32767 << 16 else 32767 |
Fredrik Svedberg | d67c0aa | 2020-03-30 13:15:28 +0200 | [diff] [blame] | 47 | reduced_shift = shift - 16 |
| 48 | |
Jacob Bohlin | c3c08d8 | 2020-08-31 10:14:02 +0200 | [diff] [blame] | 49 | if not (0 <= shift < (1 << 6)): |
| 50 | # Shift outside of valid range, set scale to 0 |
| 51 | return 0, 16 |
| 52 | |
Fredrik Svedberg | d67c0aa | 2020-03-30 13:15:28 +0200 | [diff] [blame] | 53 | return reduced_multiplier, reduced_shift |
| 54 | |
| 55 | |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 56 | # Calculate global OFM scale for Average Pooling |
| 57 | def quantise_pooling_scale(nr_kernel_elements, rescale_bits=0): |
| 58 | _, k = math.frexp(nr_kernel_elements - 1) |
| 59 | N = 31 - rescale_bits |
| 60 | scale = ((1 << (N + k)) + (1 << k)) // nr_kernel_elements |
| 61 | shift = N + k |
| 62 | |
| 63 | assert shift < (1 << 6) |
| 64 | |
| 65 | return scale, shift |
| 66 | |
| 67 | |
| 68 | # Calculate elementwise Mul OFM scale+shift |
| 69 | def elementwise_mul_scale(input_scale, input2_scale, output_scale): |
| 70 | output_rescale = (input_scale * input2_scale) / output_scale |
| 71 | out_scale, out_shift = quantise_scale(output_rescale) |
| 72 | return out_scale, out_shift |
| 73 | |
| 74 | |
| 75 | # Simplified version of calculating elementwise Add/Sub scales |
| 76 | def simplified_elementwise_add_sub_scale(input1_scale, input2_scale, output_scale, input_shift=16): |
| 77 | max_input_scale = max(input1_scale, input2_scale) |
| 78 | |
| 79 | input1_rescale = input1_scale * (1 << input_shift) / (2 * max_input_scale) |
| 80 | input2_rescale = input2_scale * (1 << input_shift) / (2 * max_input_scale) |
| 81 | output_rescale = (2 * max_input_scale) / (output_scale * (1 << input_shift)) |
| 82 | |
| 83 | out_scale, out_shift = quantise_scale(output_rescale) |
| 84 | |
| 85 | return input1_rescale, input2_rescale, out_scale, out_shift |
| 86 | |
| 87 | |
| 88 | # Advanced version of calculating elementwise Add/Sub scales |
| 89 | def advanced_elementwise_add_sub_scale(input1_scale, input2_scale, output_scale, bitdepth): |
| 90 | # Always scale the smaller of the input scales |
| 91 | max_input_scale = max(input1_scale, input2_scale) |
| 92 | min_input_scale = min(input1_scale, input2_scale) |
Fredrik Svedberg | c91dd1c | 2020-05-04 15:40:04 +0200 | [diff] [blame] | 93 | input_shift = 20 if bitdepth == 8 else 15 |
Tim Hall | 79d07d2 | 2020-04-27 18:20:16 +0100 | [diff] [blame] | 94 | op_to_scale = OperandToScale.OPa if input1_scale < input2_scale else OperandToScale.OPb |
| 95 | |
| 96 | input1_rescale, _, out_scale, out_shift = simplified_elementwise_add_sub_scale( |
| 97 | min_input_scale, max_input_scale, output_scale, input_shift |
| 98 | ) |
| 99 | |
| 100 | in_scale, in_shift = quantise_scale(input1_rescale) |
| 101 | |
| 102 | return in_scale, in_shift, out_scale, out_shift, op_to_scale |