def __init__(self, node_name, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if params.hard_act:
gen_ctrl.rnn_use_hardact = 1
names = {val: idx for idx, val in enumerate(RNNParameters.INPUT_NAMES)}
in_qs = qrec.in_qs
if in_qs[names['i_2_i_w']].bits != in_qs[names['r_2_i_w']].bits:
ValueError(f'bit width of gates differs in {params.name}')
attrs = {
'bias_size': in_qs[names['i_b']].dtype_bits // 8,
'feat_size': -in_qs[0].dtype_bits // 8,
'filter_bits': in_qs[names['i_2_i_w']].bits,
'n_cells': params.n_cells,
'k0': params.n_input_cells,
'k1': params.n_output_cells,
'dim_state': params.n_states,
'dim_in': params.n_inputs,
'always_reset': 0,
'revert': 1 if params.revert else 0,
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if qrec.out_qs[0].is_floating:
gen_ctrl.float_dump = 1
attrs = {
'n_frames': params.n_frames,
'frame_size': params.frame_size,
'frame_stride': params.frame_step,
'n_fft': params.n_fft,
'preemp_factor': params.preemp_factor,
'skip_preemp': 0,
'no_window': int(params.win_fn is None),
'out_fft': 0,
'magsquared': int(params.magsquared),
'data_type': DSP_DTYPE[qrec.out_qs[0].dtype],
}
# other attributes
extra_attrs = {'cname': cname, 'node_name': params.name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self,
node_name,
cname,
matadd_params,
act_params=None,
force_relu=True,
gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if act_params is not None:
at_act_params = gen_activation_op(act_params.activation,
force_relu=force_relu)
else:
at_act_params = "KOP_NONE"
dimensions = make_three_dims(matadd_params.in_dims[0])
attrs = {
'feat': dimensions[0],
'width': dimensions[1],
'height': dimensions[2],
'act_oper': at_act_params
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, node_name, cname, matrixadd_params, pad_params, act_params, at_ver=3, gen_ctrl=None, force_relu=True):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if act_params is not None:
at_act_params = gen_activation_op(
act_params.activation, force_relu=force_relu)
else:
at_act_params = NO_ACTIVATION
padtop = pad_params.padding[0][0]
padbot = pad_params.padding[0][1]
padded_idx = 0 if matrixadd_params.in_dims[0].size(
) > matrixadd_params.in_dims[1].size() else 1
dimensions0 = make_three_dims(matrixadd_params.in_dims[0])
dimensions1 = make_three_dims(matrixadd_params.in_dims[1])
attrs = {
'feat': max(dimensions0[0], dimensions1[0]),
'width': dimensions0[1],
'height': dimensions0[2],
'padded_idx': padded_idx,
'padtop': padtop,
'padbot': padbot,
'act_oper': at_act_params
}
extra_attrs = {
'cname': cname,
'node_name': node_name
}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self,
node_name,
cname,
linear_params,
act_params,
linear_q,
act_q,
force_relu,
gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
in_dim = linear_params.in_dims[0]
out_dim = linear_params.out_dims[0]
in_qs = linear_q.in_qs
mulbiases_q = linear_q.cache['mul_biases_q']
if act_params is not None:
at_act_params = gen_activation_op(
act_params.activation,
force_relu=force_relu,
asymmetric=act_q.in_qs[0].zero_point != 0)
if in_dim is None:
in_dim = act_params.in_dims[0]
if out_dim is None:
out_dim = act_params.out_dims[0]
out_qs = act_q.out_qs
else:
at_act_params = "KOP_NONE"
out_qs = linear_q.out_qs
attrs = {
'in_size':
in_qs[0].dtype_bits //
8 if in_qs[0].signed else -in_qs[0].dtype_bits // 8,
'out_size':
out_qs[0].dtype_bits //
8 if out_qs[0].signed else -out_qs[0].dtype_bits // 8,
'bias_size':
in_qs[2].dtype_bits // 8,
'scale_size':
mulbiases_q.dtype_bits // 8,
'filter_bits':
in_qs[1].bits,
'in_feat':
in_dim.size(),
'out_feat':
out_dim.size(),
'act_op':
at_act_params
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self,
node_name,
cname,
params,
linear_q,
act_params,
act_q,
at_ver=3,
gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
assert params is not None, "linear should always be included"
in_size = params.in_dims[0].size()
out_size = params.out_dims[0].size()
filter_q = linear_q.in_qs[1]
in_q = linear_q.in_qs[0]
out_q = linear_q.out_qs[0]
bias_q = linear_q.in_qs[2]
if act_params is not None:
act_op = gen_activation_op(act_params.activation)
out_q = act_q.out_qs[0]
if at_ver < 3:
if act_params.activation == "relu6" and out_q.q != 0:
gen_ctrl.ReluN = 6 << out_q.q
gen_ctrl.ReluNNoNorm = 1
else:
if act_params.activation == "relun":
gen_ctrl.ReluN = act_params.activation_params
else:
act_op = "KOP_NONE"
# attributes used to test equality - i.e. this kernel can be reused
attrs = {
'in_q': in_q,
'filter_q': filter_q,
'bias_q': bias_q,
'out_q': out_q,
'in_size': in_size,
'out_size': out_size,
'act_op': act_op
}
# other attributes
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
self.at_ver = at_ver
def __init__(self, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
attrs = {
'size': params.out_dims[0].size() * (qrec.out_qs[0].bits // 8)
}
# other attributes
extra_attrs = {'cname': cname, 'node_name': params.name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if qrec.out_qs[0].is_floating:
gen_ctrl.float_dump = 1
if params.log_type is not None and params.log_offset:
gen_ctrl.mfcc_log_offset = int(
np.round(params.log_offset * 2**(30)))
attrs = {
'n_frames':
params.n_frames,
'frame_size':
params.frame_size,
'frame_stride':
params.frame_step,
'n_fft':
params.n_fft,
'n_melbanks':
params.n_fbanks,
'size_mel_coeff':
params.get_melfilter_size()[0],
'n_dct':
params.n_dct,
'preemp_factor':
params.preemp_factor,
'no_window':
int(params.win_fn is None),
'lift_coeff':
0,
'magsquared':
int(params.magsquared),
'data_type':
DSP_DTYPE[qrec.out_qs[0].dtype],
'log_type':
0 if not params.log_type else
(2 if params.log_type == "db" else 1),
'out_fft':
0,
}
# other attributes
extra_attrs = {'cname': cname, 'node_name': params.name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if qrec.out_qs[0].is_floating:
gen_ctrl.float_dump = 1
attrs = {
'size': params.out_dims[0].size(),
'feature_size': (qrec.out_qs[0].dtype_bits // 8)
}
# other attributes
extra_attrs = {'cname': cname, 'node_name': params.name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, node_name, cname, params, aparams, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if isinstance(aparams,
ReluActivationParameters) and aparams.upper_bound:
gen_ctrl.ReluN = aparams.upper_bound
in_dims = params.in_dims
matop = "KOP_MATMUL" if len(in_dims) > 2 else "KOP_MATMUL_NOBIAS"
if isinstance(params, MatMulTransposedParameters):
matop += "_TRANSPOSED"
attrs = {
'ColM1':
in_dims[0][1],
'LineM1':
in_dims[0][0],
'ColM2':
in_dims[1][0] if isinstance(
params, MatMulTransposedParameters) else in_dims[1][1],
'LineM2':
in_dims[1][1] if isinstance(params, MatMulTransposedParameters)
else in_dims[1][0],
'Width':
0,
'Height':
0,
'Scx':
1,
'Scy':
1,
'kop_matmul':
matop,
'actoper':
gen_activation_op(aparams.activation if aparams else "none")
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, node_name, cname, params, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
in_dims = params.in_dims
out_dims = params.out_dims
attrs = {
'n_anchors': in_dims[0].shape[0],
'n_classes': in_dims[1][1],
'n_outboxes': out_dims[0][0],
'max_bb_before_nms': params.max_bb_before_nms,
'DecScoreThr': params.nms_score_threshold,
'NMSThr': params.nms_iou_threshold
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, node_name, cname, params, qrec, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if params.hard_act:
gen_ctrl.rnn_use_hardact = 1
gen_ctrl.gate_prenorm = qrec.cache['i_2_f_q'].pre_normalization
names = {
val: idx
for idx, val in enumerate(LSTMParameters.INPUT_NAMES)
}
in_qs = qrec.in_qs
w_bits = None
for gate in ['f', 'i', 'c', 'o']:
for inp_t in ['r', 'i']:
if w_bits is None:
w_bits = in_qs[names[f'{inp_t}_2_{gate}_w']].bits
elif w_bits != in_qs[names[f'{inp_t}_2_{gate}_w']].bits:
ValueError(f'bit width of gates differs in {params.name}')
attrs = {
'bias_size': in_qs[names['i_b']].dtype_bits // 8,
'feat_size': -in_qs[0].dtype_bits // 8,
'filter_bits': w_bits,
'n_cells': params.n_cells,
'k0': params.n_input_cells,
'k1': params.n_output_cells,
'dim_state': params.n_states,
'dim_in': params.n_inputs,
'always_reset': 0,
'revert': 1 if params.revert else 0,
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self,
node_name,
cname,
matadd_params,
act_params=None,
add_q=None,
act_q=None,
force_relu=True,
gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if not add_q.out_qs[0].signed:
gen_ctrl.output_datasize = -add_q.out_qs[0].dtype_bits // 8
if not add_q.in_qs[0].signed:
gen_ctrl.input_datasize = -add_q.in_qs[0].dtype_bits // 8
if act_params is not None:
at_act_params = gen_active_at_params(
act_params,
force_relu=force_relu,
asymmetric=act_q.in_qs[0].zero_point != 0)
else:
at_act_params = NO_ACTIVATION
dimensions = make_three_dims(matadd_params.in_dims[0])
attrs = {
'feat': dimensions[0],
'width': dimensions[1],
'height': dimensions[2],
'act_oper': at_act_params.ReLUOper
}
extra_attrs = {'cname': cname, 'node_name': node_name}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, node_name, cname, conv_params, conv_q,
pool_params, pool_q, act_params, act_q, at_ver=3, gen_ctrl=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
in_q = filter_q = out_q = bias_q = mul_biases_q = None
in_dim = out_dim = None
pad_compatibilities = []
if conv_params is not None:
at_conv_params = gen_conv_at_params(
conv_params, conv_q, pad_compatibilities)
in_dim = conv_params.in_dims[0]
out_dim = conv_params.out_dims[0]
filter_q = conv_q.in_qs[1]
in_q = conv_q.in_qs[0]
out_q = conv_q.out_qs[0]
bias_q = conv_q.in_qs[2]
if conv_params.has_mul_bias:
mul_biases_q = conv_q.mul_biases_q
else:
at_conv_params = NO_CONV
if pool_params is not None:
at_pool_params = gen_pool_at_params(
pool_params, pad_compatibilities)
if in_dim is None:
in_dim = pool_params.in_dims[0]
out_dim = pool_params.out_dims[0]
if in_q is None:
in_q = pool_q.in_qs[0]
out_q = pool_q.out_qs[0]
else:
at_pool_params = NO_POOL
if act_params is not None:
at_act_params = gen_active_at_params(act_params)
if in_dim is None:
in_dim = act_params.in_dims[0]
if out_dim is None:
out_dim = act_params.out_dims[0]
if in_q is None:
in_q = act_q.in_qs[0]
out_q = act_q.out_qs[0]
if at_ver < 3:
if act_params.activation == "relu6" and out_q.q != 0:
gen_ctrl.ReluN = 6 << out_q.q
gen_ctrl.ReluNNoNorm = 1
else:
if act_params.activation == "relun":
gen_ctrl.ReluN = act_params.activation_params
else:
at_act_params = NO_ACTIVATION
if pad_compatibilities:
reduction = PadDim.pad_compatibility_reduce(*pad_compatibilities,
"convolution padding is not compatible with pool padding")
if not reduction[2]: # default is balanced pad left
at_pad_ctrl = next(i for i, v in enumerate(reduction) if v)
LOG.debug("%s: generating pad control block", node_name)
gen_ctrl.PadType = at_pad_ctrl
attrs = {
'in_qtype': in_q,
'out_qtype': out_q,
'filter_qtype': filter_q,
'bias_qtype': bias_q,
'mul_biases_qtype': mul_biases_q,
'relu_oper': at_act_params.ReLUOper
}
if at_pool_params.PoolOper != 'KOP_NONE':
attrs.update({
'pool_oper': at_pool_params.PoolOper,
'pool_w': at_pool_params.Fpx,
'pool_h': at_pool_params.Fpy,
'pool_d_w': at_pool_params.Dpx,
'pool_d_h': at_pool_params.Dpy,
'pool_s_w': at_pool_params.Spx,
'pool_s_h': at_pool_params.Spy,
'pool_pad': at_pool_params.PoolPad
})
else:
attrs.update({
'pool_oper': 'KOP_NONE',
'pool_w': 0,
'pool_h': 0,
'pool_d_w': 0,
'pool_d_h': 0,
'pool_s_w': 0,
'pool_s_h': 0,
'pool_pad': 0
})
if at_conv_params == NO_CONV:
if in_q.dtype_bits != out_q.dtype_bits:
raise NotImplementedError(
"only homogenious operations are supported at present")
LOG.debug("%s: pool relu inq %s outq %s control block",
node_name, in_q, out_q)
if at_pool_params.PoolOper == 'KOP_NONE' and (not in_dim.is_named or not in_dim.has_keys(['c', 'w', 'h'])):
in_shape = in_dim.shape + ([1] * (3 - len(in_dim.shape)))
in_c, in_h, in_w = in_shape[0], in_shape[1], in_shape[2]
else:
in_c, in_h, in_w = in_dim.c, in_dim.h, in_dim.w
if out_dim.is_named and out_dim.has_key('c'):
out_c = out_dim.c
else:
out_c = in_c
attrs.update({
'in_c': in_c,
'in_h': in_h,
'in_w': in_w,
'out_c': out_c,
'conv_oper': 'KOP_NONE'
})
self.template = 'CALL_TEMPLATE_POOL_RELU'
else:
# swap w and h if w and filter w is 1 so generator sees 1D conv
if in_dim.w == 1 and at_conv_params.Fcx == 1:
attrs.update({
'in_c': in_dim.c,
'in_h': 1,
'in_w': in_dim.h,
'out_c': out_dim.c,
'conv_oper': at_conv_params.ConvOper,
'conv_w': at_conv_params.Fcy,
'conv_h': 1,
'conv_d_w': at_conv_params.Dcy,
'conv_d_h': at_conv_params.Dcx,
'conv_s_w': at_conv_params.Scy,
'conv_s_h': at_conv_params.Scx,
'conv_pad': at_conv_params.ConvPad
})
else:
attrs.update({
'in_c': in_dim.c,
'in_h': in_dim.h,
'in_w': in_dim.w,
'out_c': out_dim.c,
'conv_oper': at_conv_params.ConvOper,
'conv_w': at_conv_params.Fcx,
'conv_h': at_conv_params.Fcy,
'conv_d_w': at_conv_params.Dcx,
'conv_d_h': at_conv_params.Dcy,
'conv_s_w': at_conv_params.Scx,
'conv_s_h': at_conv_params.Scy,
'conv_pad': at_conv_params.ConvPad
})
if isinstance(at_conv_params, ConvATParam):
if mul_biases_q is not None:
LOG.debug("%s: mulconv pool relu inq %s outq %s control block",
node_name, in_q, out_q)
self.template = 'CALL_TEMPLATE_MULBIAS_CONV_POOL_RELU'
else:
LOG.debug("%s: conv pool relu inq %s outq %s control block",
node_name, in_q, out_q)
self.template = 'CALL_TEMPLATE_CONV_POOL_RELU'
elif isinstance(at_conv_params, GroupedConvATParam):
attrs.update({
'group_in': at_conv_params.GroupIn,
'group_out': at_conv_params.GroupOut
})
if mul_biases_q is not None:
LOG.debug("%s: grouped conv pool relu inq %s outq %s control block",
node_name, in_q, out_q)
self.template = 'CALL_TEMPLATE_GROUPED_MULBIAS_CONV_POOL_RELU'
else:
LOG.debug("%s: grouped mulconv pool relu inq %s outq %s control block",
node_name, in_q, out_q)
self.template = 'CALL_TEMPLATE_GROUPED_CONV_POOL_RELU'
else:
raise ValueError('Internal error')
# other attributes
extra_attrs = {
'cname': cname,
'node_name': node_name
}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
def __init__(self, cname, params, matmul_params, matmul_qrec, act_params, act_qrec, gen_ctrl=None, out_qtype=None):
if gen_ctrl is None:
gen_ctrl = GenCtrl(None, cname=cname)
else:
gen_ctrl.cname = cname
if len(params.in_dims[0]) != 2 or len(params.in_dims[1]) != 2:
raise ValueError(f'Matmul {params.name} has inputs of rank {len(params.in_dims[0])} and {len(params.in_dims[1])}'
f'which are not supported by the matmul kernel')
in1_shape = params.in_dims[0].shape
in2_shape = params.in_dims[1].shape
height_2 = in2_shape[0]
width_2 = in2_shape[1]
out_shape = params.out_dims[0].shape
in1_qtype = matmul_qrec.in_qs[0]
in2_qtype = matmul_qrec.in_qs[1]
if len(matmul_params.in_dims) == 3:
bias_bits = at_bits(matmul_qrec.in_qs[2])
bias_q = matmul_qrec.in_qs[2].q
matmul_op = 'KOP_MATMUL'
else:
bias_q = 0
bias_bits = 0
matmul_op = 'KOP_MATMUL_NOBIAS'
if isinstance(matmul_params, MatMulTransposedParameters):
matmul_op += '_TRANSPOSED'
height_2 = in2_shape[1]
width_2 = in2_shape[0]
if act_params is not None:
act_op = gen_activation_op(act_params.activation)
out_qtype = act_qrec.out_qs[0]
relu_lower = 0
if act_params.activation == "relu6" and out_qtype.q != 0:
relu_upper = 6 << out_qtype.q
else:
relu_upper = 0
else:
out_qtype = matmul_qrec.out_qs[0]
relu_upper = relu_lower = 0
act_op = "KOP_NONE"
# attributes used to test equality - i.e. this kernel can be reused
attrs = {
'in1_qtype': in1_qtype,
'in2_qtype': in2_qtype,
'bias_q': bias_q,
'bias_bits': bias_bits,
'out_qtype': out_qtype,
'in1_shape': in1_shape,
'height_2': height_2,
'width_2': width_2,
'out_shape': out_shape,
'relu_lower': relu_lower,
'relu_upper': relu_upper,
'mult_op': matmul_op,
'act_op': act_op
}
# other attributes
extra_attrs = {
'cname': cname,
'node_name': params.name
}
super().__init__(attrs, extra_attrs, gen_ctrl=gen_ctrl)
