def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
details = kwargs.get('details')
if details is not None:
current_control = SymbolStats()
Symbol.set_default_control(current_control)
results = {}
else:
results = None
current_control = None
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="float32")
in_vars = {
params.input_symbols[i]: in_tensor
for i, in_tensor in enumerate(in_tensors)
}
out_vars = params.func_col(**in_vars,
calculate_ranges=current_control
is not None,
track_results=results)
out_tensors = [
out_vars[out_sym_name] for out_sym_name in params.output_symbols
]
if current_control:
details.update(current_control.stats)
details['results'] = results
return qrec.get_outputs(params, out_tensors, ktype="float32")
def expression(params, in_tensors, qrec: QuantizationRecordBase, details=None):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="float32")
return qrec.get_outputs(params,
params.execute(in_tensors, details=details),
ktype="float32")
def sigmoid(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
return qrec.get_outputs(params, [1 / (1 + np.exp(-in_tensor))],
ktype="float32")
def av_global_pool(params,
in_tensors,
qrec: QuantizationRecordBase,
details=None):
if isinstance(qrec, MultQuantizationRecord):
return av_global_pool_mult(params, in_tensors, qrec, details=details)
# Prepare the quantization levels
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")[0]
in_dims = params.in_dims[0]
out_dims = params.out_dims[0]
sum_by_chan = np.sum(in_tensor,
dtype=np.int32,
axis=(in_dims.get_order_idx('w'),
in_dims.get_order_idx('h')))
norm = (np.array([31], dtype=np.int32) - gap_clb(sum_by_chan)).astype(
np.int32)
inv_wh = (1 << norm) // (in_dims.h * in_dims.w)
out_tensor = at_norm((inv_wh * sum_by_chan), norm)
return qrec.get_outputs(
params, [qrec.out_qs[0].clip(out_tensor).reshape(out_dims.shape)],
ktype="symmetric")
def resize_nearest_neighbor(params,
in_tensors,
qrec: QuantizationRecordBase,
details=None):
del details
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")[0]
in_tensor = in_tensor.transpose(params.in_dims[0].transpose_to_order(
("h", "w", "c")))
w_out = params.out_dims[0].w
h_out = params.out_dims[0].h
c_out = params.out_dims[0].c
w_in = params.in_dims[0].w
h_in = params.in_dims[0].h
wstep = ((w_in - 1) << 16) // (w_out - 1)
hstep = ((h_in - 1) << 16) // (h_out - 1)
out_tensor = np.empty((h_out, w_out, c_out))
for i in range(h_out):
h_rounded = ((hstep * i) + (1 << (16 - 1))) >> 16
for j in range(w_out):
w_rounded = ((wstep * j) + (1 << (16 - 1))) >> 16
out_tensor[i, j, :] = in_tensor[h_rounded, w_rounded, :]
out_tensor = out_tensor.transpose(params.out_dims[0].transpose_from_order(
("h", "w", "c")))
return qrec.get_outputs(params, [out_tensor], ktype="symmetric")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
in_tensor = in_tensor.transpose(params.in_dims[0].transpose_to_order(
("h", "w", "c")))
w_out = params.out_dims[0].w
h_out = params.out_dims[0].h
c_out = params.out_dims[0].c
w_in = params.in_dims[0].w
h_in = params.in_dims[0].h
wstep = (w_in - 1) / (w_out - 1)
hstep = (h_in - 1) / (h_out - 1)
out_tensor = np.empty((h_out, w_out, c_out))
for i in range(h_out):
h_rounded = int(round(hstep * i))
for j in range(w_out):
w_rounded = int(round(wstep * j))
out_tensor[i, j, :] = in_tensor[h_rounded, w_rounded, :]
out_tensor = out_tensor.transpose(
params.out_dims[0].transpose_from_order(("h", "w", "c")))
return qrec.get_outputs(params, [out_tensor], ktype="float32")
def softmax(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
np.seterr(over='raise')
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
return qrec.get_outputs(params, [softmax_func(in_tensor)], ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
qname = kwargs['qname']
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype=qname)[0]
out_tensors = [in_tensor]
return qrec.get_outputs(params, out_tensors, ktype=qname)
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
qname = kwargs['qname']
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype=qname)[0]
return qrec.get_outputs(params, [np.flip(in_tensor, axis=params.axis)],
ktype=qname)
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")
if params.transpose_in:
in_tensors = [(np.transpose(in_tensor, params.transpose_in[idx])
if params.transpose_in[idx] else in_tensor)
for idx, in_tensor in enumerate(in_tensors)]
if isinstance(params, Broadcastable) and params.is_broadcasted:
in_tensors = params.broadcast_inputs(in_tensors)
func = PIECEWISE_OPS[params.__class__]
op = func['op']
if func['is_mult']:
qrec.set_scale(in_idx=(0, 1), out_idx=0)
i1 = in_tensors[0].astype(np.int32)
i2 = in_tensors[1].astype(np.int32)
out_tensor = qrec.scale_mul_biases_q.apply_scales(
op(i1, i2, np.int32))
else:
# larger scale should be scaled
qrec.set_add_scale()
if qrec.scaled_idx:
i1 = in_tensors[0].astype(np.int32)
i2 = qrec.scale_in_mul_biases_q.apply_scales(in_tensors[1])
else:
i1 = qrec.scale_in_mul_biases_q.apply_scales(in_tensors[0])
i2 = in_tensors[1].astype(np.int32)
out_tensor = qrec.scale_mul_biases_q.apply_scales(op(i1, i2, None))
if params.transpose_out:
out_tensor = np.transpose(out_tensor, params.transpose_out[0])
return qrec.get_outputs(params, [qrec.out_qs[0].clip(out_tensor)],
ktype="symmetric")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
in_tensor = in_tensor.transpose(params.in_dims[0].transpose_to_order(
("h", "w", "c")))
w_out = params.out_dims[0].w
h_out = params.out_dims[0].h
c_out = params.out_dims[0].c
w_in = params.in_dims[0].w
h_in = params.in_dims[0].h
wstep = (w_in - 1) / w_out
hstep = (h_in - 1) / h_out
out_tensor = np.empty((h_out, w_out, c_out))
for i in range(h_out):
y_l, y_h = math.floor(hstep * i), math.ceil(hstep * i)
hc = (hstep * i) - y_l
for j in range(w_out):
x_l, x_h = math.floor(wstep * j), math.ceil(wstep * j)
wc = (wstep * j) - x_l
P1 = in_tensor[y_l, x_l, :]
P2 = in_tensor[y_l, x_h, :]
P3 = in_tensor[y_h, x_l, :]
P4 = in_tensor[y_h, x_h, :]
out_tensor[i, j, :] = P1 * (1 - wc) * (1 - hc) \
+ P2 * wc * (1 - hc) \
+ P3 * (1 - wc) * hc \
+ P4 * wc * hc
out_tensor = out_tensor.transpose(
params.out_dims[0].transpose_from_order(("h", "w", "c")))
return qrec.get_outputs(params, [out_tensor], ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
qname = kwargs['qname']
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype=qname)[0]
out_tensor = np.take(in_tensor, params.indices, axis=params.axis)
return qrec.get_outputs(params, [out_tensor], ktype=qname)
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
del kwargs
in_tensor = qrec.prepare_inputs(params, in_tensors,
ktype="symmetric")[0]
args = {
params.INPUT_NAMES[idx]: [in_tensors[idx], qrec.in_qs[idx]]
for idx in range(1, len(in_tensors))
}
if params.revert:
in_tensor = np.flip(in_tensor, axis=0)
assert in_tensor.shape[
0] == params.n_input_cells, "input shape incorrect - n_input_cells"
assert in_tensor.shape[
1] == params.n_inputs, "input shape incorrect - n_inputs"
out_tensor = np.zeros([params.n_output_cells, params.n_states],
dtype=qrec.out_qs[0].dtype)
out_idx = 0
for idx in range(params.n_cells):
res = cls.step_kernel(params, args, idx, in_tensor, qrec)
if idx >= (params.n_cells - params.n_output_cells):
out_tensor[out_idx] = res
out_idx += 1
if params.revert:
out_tensor = np.flip(out_tensor, axis=0)
if params.output_directions:
out_tensor = np.expand_dims(out_tensor, 0)
return [out_tensor]
def cast(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
out_tensors = [in_tensor]
return qrec.get_outputs(params, out_tensors, ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
details = kwargs['details']
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
args = {
params.INPUT_NAMES[idx]: in_tensors[idx]
for idx in range(1, len(in_tensors))
}
if params.always_reset_state:
for state_key in params.STATE_PARAMETERS:
args[state_key] = args[state_key].copy()
assert in_tensor.shape[
0] == params.n_input_cells, "input shape incorrect - n_input_cells"
assert in_tensor.shape[
1] == params.n_inputs, "input shape incorrect - n_inputs"
if params.revert:
in_tensor = np.flip(in_tensor, axis=0)
out_tensor = np.zeros([params.n_output_cells, params.n_states])
out_idx = 0
if details is not None:
details['range_state'] = {
'min': float('inf'),
'max': float('-inf')
}
if isinstance(params, LSTMParameters):
details['range_cell'] = {
'min': float('inf'),
'max': float('-inf')
}
for idx in range(params.n_cells):
res = cls.step_kernel(params,
args,
idx,
in_tensor,
details=details)
if idx >= (params.n_cells - params.n_output_cells):
out_tensor[out_idx] = res
out_idx += 1
if details is not None:
details['range_state']['min'] = min(
details['range_state']['min'], res.min())
details['range_state']['max'] = max(
details['range_state']['max'], res.max())
if isinstance(params, LSTMParameters):
details['range_cell']['min'] = min(
details['range_cell']['min'], args['c_state'].min())
details['range_cell']['max'] = max(
details['range_cell']['max'], args['c_state'].max())
if params.revert:
out_tensor = np.flip(out_tensor, axis=0)
if params.output_directions:
out_tensor = np.expand_dims(out_tensor, 0)
return [out_tensor]
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
return qrec.get_outputs(params, [1 / (1 + np.exp(-in_tensor))],
ktype="float32")
def hsigmoid(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
return qrec.get_outputs(
params, [np.minimum(np.maximum(in_tensor + params.offset, 0), 6) / 6],
ktype="float32")
def execute_piecewise(cls, params, in_tensors,
qrec: QuantizationRecordBase, op, **kwargs):
del kwargs
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="float32")
return qrec.get_outputs(params, [op(in_tensors[0], in_tensors[1])],
ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
qname = kwargs['qname']
params = typing_cast(StridedSliceParameters, params)
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype=qname)[0]
out_tensors = [params.numpy_slice(in_tensor)]
return qrec.get_outputs(params, out_tensors, ktype=qname)
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
qname = kwargs['qname']
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype=qname)[0]
if params.transpose_in:
in_tensor = np.transpose(in_tensor, params.transpose_in[0])
return qrec.get_outputs(params, [in_tensor], ktype=qname)
def leaky(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
output = in_tensor * (in_tensor >
0) + in_tensor * params.leak_factor * (in_tensor < 0)
return qrec.get_outputs(params, [output], ktype="float32")
def transpose(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
if params.transpose_in:
in_tensor = np.transpose(in_tensor, params.transpose_in[0])
return qrec.get_outputs(params, [in_tensor], ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="float32")
return qrec.get_outputs(params,
params.execute(in_tensors),
ktype="float32")
def strided_slice(params,
in_tensors,
qrec: QuantizationRecordBase,
details=None):
del details
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")[0]
out_tensors = [params.numpy_slice(in_tensor)]
return qrec.get_outputs(params, out_tensors, ktype="symmetric")
def piecewise(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if qrec is None:
qrec = Float32QuantizationRecord()
func = PIECEWISE_OPS[params.__class__]
op = func['op']
in_tensors = qrec.prepare_inputs(params, in_tensors, ktype="float32")
return qrec.get_outputs(params, [op(in_tensors[0], in_tensors[1])],
ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
output = in_tensor * (
in_tensor > 0) + in_tensor * params.leak_factor * (in_tensor < 0)
return qrec.get_outputs(params, [output], ktype="float32")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
if qrec is None:
qrec = Float32QuantizationRecord()
old_err = np.seterr(over='raise')
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
in_tensor = softmax_func(in_tensor)
np.seterr(**old_err)
return qrec.get_outputs(params, [in_tensor], ktype="float32")
def transpose(params,
in_tensors,
qrec: QuantizationRecordBase,
details=None):
del details
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")[0]
if params.transpose_in:
in_tensor = np.transpose(in_tensor, params.transpose_in)
return qrec.get_outputs(params, [in_tensor], ktype="symmetric")
def execute(cls, params, in_tensors, qrec: QuantizationRecordBase,
**kwargs):
details = kwargs.get('details')
# qrec is set by default to Float32QuantizationRecord if None
if qrec is None or isinstance(qrec, Float32QuantizationRecord):
qrec = Float32ScalableFilterQuantizationRecord()
in_dims = params.in_dims[0]
out_dims = params.out_dims[0]
weights = qrec.prepare_weights(params,
params.get_uncompressed_weights(),
ktype="float32")
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="float32")[0]
if details is not None:
details['min_acc'] = float("Infinity")
details['max_acc'] = float("-Infinity")
if params.has_bias:
biases = qrec.prepare_biases(params,
params.get_uncompressed_biases(),
params.get_uncompressed_weights(),
ktype="float32")
acc_tensor = np.ones(out_dims.shape, dtype=np.float32) * biases
else:
acc_tensor = np.zeros(out_dims.shape, dtype=np.float32)
in_tensor = in_tensor.reshape((in_dims.size()))
filt = params.filter.get_filter_dims()
for out_c in range(out_dims.c):
# Expand and normalize the accumulator
w_slice = weights[filt.srange(out_c=out_c)].reshape(
(in_dims.size()))
res = np.dot(in_tensor, w_slice)
if details is not None:
details['min_acc'] = min(np.sum(res[res < 0]),
details['min_acc'])
details['max_acc'] = min(np.sum(res[res > 0]),
details['max_acc'])
acc_tensor[out_c] += res
if details is not None:
details['min_acc'] = min(np.min(acc_tensor[out_c]),
details['min_acc'])
details['max_acc'] = max(np.max(acc_tensor[out_c]),
details['max_acc'])
acc_tensor = qrec.apply_multiplicative_bias(params,
acc_tensor,
0,
ktype="float32")
return qrec.get_outputs(params, [acc_tensor], ktype="float32")
def sigmoid(params, in_tensors, qrec: QuantizationRecordBase, details=None):
del details
if isinstance(qrec, MultQuantizationRecord):
raise NotImplementedError()
in_tensor = qrec.prepare_inputs(params, in_tensors, ktype="symmetric")[0]
dqinput = qrec.in_qs[0].dequantize(in_tensor)
return qrec.get_outputs(
params, [qrec.out_qs[0].quantize(1 / (1 + np.exp(-dqinput)))],
ktype="symmetric")
