def make_default_quantizer(self, mode) -> quantizer_impl.IQuantizer:
"""make quantizer given qkeras quantizer type."""
if mode == "fp32":
return quantizer_impl.FloatingPoint(bits=32)
elif mode == "fp16":
return quantizer_impl.FloatingPoint(bits=16)
elif mode == "int8":
qbits = quantizer_impl.QuantizedBits()
qbits.convert_qkeras_quantizer(quantizers.quantized_bits(8, 0, 1))
return qbits
elif mode == "int16":
qbits = quantizer_impl.QuantizedBits()
qbits.convert_qkeras_quantizer(quantizers.quantized_bits(16, 7, 1))
return qbits
elif mode == "int32":
qbits = quantizer_impl.QuantizedBits()
qbits.convert_qkeras_quantizer(quantizers.quantized_bits(
32, 10, 1))
return qbits
else:
try:
# string to quantizer object
q_name = "quantizers." + mode
qkeras_object = eval(q_name) # pylint: disable=eval-used
return self._make_quantizer_util(qkeras_object)
except: # pylint: disable=bare-except
raise ValueError("unaccepted quantizer {}!".format(mode))
def test_big_bias_quantizer():
q1 = quantizer_impl.QuantizedBits()
q1.convert_qkeras_quantizer(quantizers.quantized_bits(8, 3))
q2 = quantizer_impl.QuantizedBits()
q2.convert_qkeras_quantizer(quantizers.quantized_bits(16, 4))
r = adder_impl.FixedPointAdder(q1, q2)
# int_bits = max(q1.int_bits, q2.int_bits) + 1
# bits = int_bits + sign_bit + max(q1_fraction_bit, q2_fraction bit)
assert r.output.bits == 17
assert r.output.int_bits == 5
def __init__(self):
# also attached the output datatype in the table
self.divider_impl_table = [
[
# when qbits is denominator, use default bits for float result
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(
bits=quantizer_impl.FLOATINGPOINT_BITS)),
(divider_impl.Shifter, quantizer_impl.QuantizedBits()),
(None, None),
(None, None),
(None, None),
# when bits sets to None, will decide f16/f32 according
# to input quantizer
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))
],
[(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(
bits=quantizer_impl.FLOATINGPOINT_BITS)),
(divider_impl.Subtractor, quantizer_impl.PowerOfTwo()),
(None, None), (None, None), (None, None),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))],
[(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(
bits=quantizer_impl.FLOATINGPOINT_BITS)),
(divider_impl.Shifter, quantizer_impl.QuantizedBits()),
(None, None), (None, None), (None, None),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))],
[(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(
bits=quantizer_impl.FLOATINGPOINT_BITS)),
(divider_impl.Shifter, quantizer_impl.PowerOfTwo()), (None, None),
(None, None), (None, None),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))],
[(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(
bits=quantizer_impl.FLOATINGPOINT_BITS)),
(divider_impl.Shifter, quantizer_impl.PowerOfTwo()), (None, None),
(None, None), (None, None),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))],
[(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None)),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None)), (None, None),
(None, None), (None, None),
(divider_impl.FloatingPointDivider,
quantizer_impl.FloatingPoint(bits=None))]
]
def __init__(self):
# the table below is found in this slides:
# https://docs.google.com/presentation/d/1pcmoB6ZpX0IqjhSwgzO-oQwpMRYwIcDe/edit#slide=id.p40
# also attached the output datatype in the table
self.multiplier_impl_table = [
[(multiplier_impl.FixedPointMultiplier,
quantizer_impl.QuantizedBits()),
(multiplier_impl.Shifter, quantizer_impl.QuantizedBits()),
(multiplier_impl.Mux, quantizer_impl.QuantizedBits()),
(multiplier_impl.Mux, quantizer_impl.QuantizedBits()),
(multiplier_impl.AndGate, quantizer_impl.QuantizedBits()),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))],
[(multiplier_impl.Shifter, quantizer_impl.QuantizedBits()),
(multiplier_impl.Adder, quantizer_impl.PowerOfTwo()),
(multiplier_impl.Mux, quantizer_impl.PowerOfTwo()),
(multiplier_impl.Mux, quantizer_impl.PowerOfTwo()),
(multiplier_impl.AndGate, quantizer_impl.PowerOfTwo()),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))],
[(multiplier_impl.Mux, quantizer_impl.QuantizedBits()),
(multiplier_impl.Mux, quantizer_impl.PowerOfTwo()),
(multiplier_impl.Mux, quantizer_impl.Ternary()),
(multiplier_impl.Mux, quantizer_impl.Ternary()),
(multiplier_impl.AndGate, quantizer_impl.Ternary()),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))],
[(multiplier_impl.Mux, quantizer_impl.QuantizedBits()),
(multiplier_impl.Mux, quantizer_impl.PowerOfTwo()),
(multiplier_impl.Mux, quantizer_impl.Ternary()),
(multiplier_impl.XorGate, quantizer_impl.Binary(use_01=False)),
(multiplier_impl.AndGate, quantizer_impl.Ternary()),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))],
[(multiplier_impl.AndGate, quantizer_impl.QuantizedBits()),
(multiplier_impl.AndGate, quantizer_impl.PowerOfTwo()),
(multiplier_impl.AndGate, quantizer_impl.Ternary()),
(multiplier_impl.AndGate, quantizer_impl.Ternary()),
(multiplier_impl.AndGate, quantizer_impl.Binary(use_01=True)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))],
[(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None)),
(multiplier_impl.FloatingPointMultiplier,
quantizer_impl.FloatingPoint(bits=None))]
]
def __init__(
self,
kernel_shape,
multiplier: multiplier_impl.IMultiplier,
):
super().__init__()
if len(kernel_shape) not in (
2,
4,
):
logging.fatal("unsupported kernel shape, "
"it is neither a dense kernel of length 2,"
" nor a convolution kernel of length 4")
kernel_shape_excluding_output_dim = kernel_shape[:-1]
kernel_add_ops = np.prod(kernel_shape_excluding_output_dim)
# bias are associate with filters; each filter adds 1 bias
bias_add = 1
add_ops = kernel_add_ops + bias_add
self.log_add_ops = int(np.ceil(np.log2(add_ops)))
self.multiplier = multiplier
self.output = quantizer_impl.QuantizedBits()
self.output.bits = self.log_add_ops + self.multiplier.output.bits
self.output.int_bits = self.log_add_ops + self.multiplier.output.int_bits
self.output.is_signed = self.multiplier.output.is_signed
self.output.op_type = "accumulator"
assert not self.multiplier.output.is_floating_point
self.output.is_floating_point = False
def __init__(self, quantizer_1, quantizer_2):
self.output = quantizer_impl.QuantizedBits()
self.output.bits = max(quantizer_1.bits, quantizer_2.bits) + 1
self.output.int_bits = max(quantizer_1.int_bits,
quantizer_2.int_bits) + 1
self.output.is_signed = quantizer_1.is_signed | quantizer_2.is_signed
self.output.mode = 0
self.output.is_floating_point = False
self.output.is_po2 = 0
def po2_qbits_converter(po2_quantizer: quantizer_impl.IQuantizer):
"""convert a po2 quantizer to fixedpoint quantizer."""
(bits_from_po2,
int_bits_from_po2) = accumulator_impl.po2_to_qbits(po2_quantizer)
qbits_quantizer = quantizer_impl.QuantizedBits()
qbits_quantizer.bits = bits_from_po2
qbits_quantizer.int_bits = int_bits_from_po2
qbits_quantizer.is_signed = po2_quantizer.is_signed
return qbits_quantizer
def __init__(self, input_qe_list):
super().__init__(input_qe_list)
is_same = True
is_floating_point = False
bits = 0
quantizer = self.input_quantizers[0]
for cur in self.input_quantizers[1:]:
if (quantizer.name != cur.name or quantizer.bits != cur.bits
or quantizer.int_bits != cur.int_bits
or quantizer.is_signed != cur.is_signed):
is_same = False
break
if is_same:
self.output = quantizer
else:
max_bits = -1
max_int_bits = -1
is_signed = False
for quantizer in self.input_quantizers:
if quantizer.is_floating_point:
is_floating_point = True
bits = max(bits, quantizer.bits)
else:
if quantizer.is_po2:
qbits_quantizer = adder_impl.po2_qbits_converter(
quantizer)
else:
qbits_quantizer = quantizer
if qbits_quantizer.bits > max_bits:
max_bits = qbits_quantizer.bits
if qbits_quantizer.int_bits > max_int_bits:
max_int_bits = qbits_quantizer.int_bits
is_signed |= quantizer.is_signed
if is_floating_point:
self.output = quantizer_impl.FloatingPoint(bits=bits)
else:
self.output = quantizer_impl.QuantizedBits()
self.output.bits = max_bits
self.output.int_bits = max_int_bits
self.output.is_signed = is_signed
self.output.mode = 0
self.output.is_floating_point = False
self.output.is_po2 = 0
self.gate_factor = 0.2
self.gate_bits = self.output.bits
def test_QuantizedBits():
qkeras_quantizer = quantizers.quantized_bits()
qtools_quantizer = quantizer_impl.QuantizedBits()
qtools_quantizer.convert_qkeras_quantizer(qkeras_quantizer)
new_quantizer = qtools_quantizer.convert_to_qkeras_quantizer(
symmetric=qkeras_quantizer.symmetric, alpha=qkeras_quantizer.alpha,
use_stochastic_rounding=qkeras_quantizer.use_stochastic_rounding,
scale_axis=qkeras_quantizer.scale_axis,
qnoise_factor=qkeras_quantizer.qnoise_factor)
result = new_quantizer.__dict__
for (key, val) in result.items():
assert_equal(val, qkeras_quantizer.__dict__[key])
def __init__(self, quantizer_1, quantizer_2):
self.output = quantizer_impl.QuantizedBits()
self.output.int_bits = max(quantizer_1.int_bits,
quantizer_2.int_bits) + 1
fractional_bits1 = (quantizer_1.bits - int(quantizer_1.is_signed) -
quantizer_1.int_bits)
fractional_bits2 = (quantizer_2.bits - int(quantizer_2.is_signed) -
quantizer_2.int_bits)
fractional_bits = max(fractional_bits1, fractional_bits2)
self.output.is_signed = quantizer_1.is_signed | quantizer_2.is_signed
self.output.bits = (self.output.int_bits + int(self.output.is_signed) +
fractional_bits)
self.output.mode = 0
self.output.is_floating_point = False
self.output.is_po2 = 0
def __init__(self, input_qe_list):
super().__init__(input_qe_list)
max_bits = -1
max_int_bits = -1
is_signed = False
bits = 0
is_floating_point = False
for quantizer in self.input_quantizers:
if quantizer.is_floating_point:
is_floating_point = True
bits = max(bits, quantizer.bits)
else:
if quantizer.is_po2:
qbits_quantizer = adder_impl.po2_qbits_converter(quantizer)
else:
qbits_quantizer = quantizer
if qbits_quantizer.bits > max_bits:
max_bits = qbits_quantizer.bits
if qbits_quantizer.int_bits > max_int_bits:
max_int_bits = qbits_quantizer.int_bits
is_signed |= quantizer.is_signed
if is_floating_point:
self.output = quantizer_impl.FloatingPoint(bits=bits)
else:
self.output = quantizer_impl.QuantizedBits()
self.output.bits = max_bits + 1
self.output.int_bits = max_int_bits + 1
self.output.is_signed = is_signed
self.output.mode = 0
self.output.is_floating_point = False
self.output.is_po2 = 0
self.gate_factor = 1
self.gate_bits = self.output.bits