def test_move_chw_add_past_conv(idim, k, s, ich, och):
odim = compute_conv_output_dim(idim, k, s)
ishape = [1, ich, idim, idim]
oshape = [1, och, odim, odim]
add_param_shape = [1, ich, 1, 1]
conv_param_shape = [och, ich, k, k]
inp = helper.make_tensor_value_info("inp", TensorProto.FLOAT, ishape)
outp = helper.make_tensor_value_info("outp", TensorProto.FLOAT, oshape)
a0 = helper.make_tensor_value_info("a0", TensorProto.FLOAT, add_param_shape)
a1 = helper.make_tensor_value_info("a1", TensorProto.FLOAT, conv_param_shape)
conv_config = {}
conv_config["dilations"] = [1, 1]
conv_config["group"] = 1
conv_config["kernel_shape"] = [k, k]
conv_config["pads"] = [0, 0, 0, 0]
conv_config["strides"] = [s, s]
add_node = helper.make_node("Add", ["inp", "a0"], ["add_out"])
conv_node = helper.make_node("Conv", ["add_out", "a1"], ["outp"], **conv_config)
model = helper.make_model(
helper.make_graph(
nodes=[add_node, conv_node],
name="move-add-graph",
inputs=[inp],
outputs=[outp],
value_info=[a0, a1],
)
)
model = ModelWrapper(model)
# initialize model
a0_values = np.random.uniform(low=0, high=1, size=tuple(add_param_shape)).astype(
np.float32
)
model.set_initializer("a0", a0_values)
a1_values = np.random.uniform(low=0, high=1, size=tuple(conv_param_shape)).astype(
np.float32
)
model.set_initializer("a1", a1_values)
model = model.transform(InferShapes())
# execution before transformation
inp_values = np.random.uniform(low=0, high=1, size=tuple(ishape)).astype(np.float32)
idict = {model.graph.input[0].name: inp_values}
odict = oxe.execute_onnx(model, idict)
y_before = odict[model.graph.output[0].name]
model = model.transform(MoveAddPastConv())
odict = oxe.execute_onnx(model, idict)
y_after = odict[model.graph.output[0].name]
assert np.isclose(y_before, y_after).all()
assert model.graph.node[0].op_type == "Conv"
assert model.graph.node[1].op_type == "Add"
def get_normal_output_shape(self):
k = self.get_nodeattr("ConvKernelDim")
ifm_dim = self.get_nodeattr("IFMDim")
ifm_ch = self.get_nodeattr("IFMChannels")
stride = self.get_nodeattr("Stride")
pad = 0
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad)
oshape = (1, ofm_dim, ofm_dim, k * k * ifm_ch)
return oshape
def get_normal_output_shape(self):
k = self.get_nodeattr("PoolDim")
ifm_dim = self.get_nodeattr("ImgDim")
ifm_ch = self.get_nodeattr("NumChannels")
stride = k
pad = 0
assert ifm_dim % k == 0, "StreamingMaxPool needs ImgDim % PoolDim == 0"
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad)
oshape = (1, ofm_dim, ofm_dim, ifm_ch)
return oshape
def test_depthwise_conv_lowering(idt, k, ifm_dim, ifm_ch, stride, padding):
wdt = idt
odt = DataType.INT32
ofm_ch = ifm_ch
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad=padding[0])
# set up onnx model
inp = oh.make_tensor_value_info("inp", TensorProto.FLOAT,
[1, ifm_ch, ifm_dim, ifm_dim])
outp = oh.make_tensor_value_info("outp", TensorProto.FLOAT,
[1, ofm_ch, ofm_dim, ofm_dim])
W = oh.make_tensor_value_info("W", TensorProto.FLOAT, [ofm_ch, 1, k, k])
dw_cnv = oh.make_node(
"Conv",
inputs=["inp", "W"],
outputs=["outp"],
kernel_shape=[k, k],
pads=padding,
strides=[stride, stride],
group=ifm_ch,
)
graph = oh.make_graph(
nodes=[dw_cnv],
name="dw_cnv_graph",
inputs=[inp],
outputs=[outp],
value_info=[W],
)
model = oh.make_model(graph, producer_name="dws_cnv-model")
model = ModelWrapper(model)
model.set_tensor_datatype("inp", idt)
model.set_tensor_datatype("outp", odt)
model.set_tensor_datatype("W", wdt)
w_tensor = gen_finn_dt_tensor(wdt, [ofm_ch, 1, k, k])
model.set_initializer("W", w_tensor)
model = model.transform(InferShapes())
input_tensor = gen_finn_dt_tensor(idt, [1, ifm_ch, ifm_dim, ifm_dim])
input_dict = {"inp": input_tensor}
output_dict = oxe.execute_onnx(model, input_dict)
expected = output_dict["outp"]
model = model.transform(LowerConvsToMatMul())
output_dict = oxe.execute_onnx(model, input_dict)
produced = output_dict["outp"]
assert (produced == expected).all()
# check if created nodes have attributes that indicate depthwise conv
assert model.get_tensor_sparsity("W") is not None
im2col_node = getCustomOp(model.graph.node[1])
assert im2col_node.get_nodeattr("depthwise") == 1
def get_folded_output_shape(self):
k = self.get_nodeattr("ConvKernelDim")
ifm_dim = self.get_nodeattr("IFMDim")
ifm_ch = self.get_nodeattr("IFMChannels")
stride = self.get_nodeattr("Stride")
simd = self.get_nodeattr("SIMD")
pad = 0
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad)
assert ifm_ch % simd == 0, "SIMD must divide IFMChannels"
wf = int((k * k * ifm_ch) // simd)
folded_oshape = (1, ofm_dim, ofm_dim, wf, simd)
return folded_oshape
def test_convert_to_hls_conv_layer(conv_config, depthwise, exec_mode):
kernel_size, stride, pad = conv_config
np.random.seed(0)
idt = DataType.UINT4
in_feature_dim = 7
in_chn = 16
if depthwise is True:
group = out_chn = in_chn
conv_param_shape = [out_chn, 1, kernel_size, kernel_size]
else:
group = 1
out_chn = 20
conv_param_shape = [out_chn, in_chn, kernel_size, kernel_size]
out_feature_dim = compute_conv_output_dim(in_feature_dim, kernel_size, stride, pad)
input_shape = [1, in_chn, in_feature_dim, in_feature_dim]
output_shape = [1, out_chn, out_feature_dim, out_feature_dim]
conv_weight_dt = DataType.UINT4
conv_config = {}
conv_config["dilations"] = [1, 1]
conv_config["group"] = group
conv_config["kernel_shape"] = [kernel_size, kernel_size]
conv_config["pads"] = [pad, pad, pad, pad]
conv_config["strides"] = [stride, stride]
top_in = helper.make_tensor_value_info("top_in", TensorProto.FLOAT, input_shape)
top_out = helper.make_tensor_value_info("top_out", TensorProto.FLOAT, output_shape)
value_info = [
helper.make_tensor_value_info("p1", TensorProto.FLOAT, conv_param_shape)
]
modelproto = helper.make_model(
helper.make_graph(
name="conv_test",
inputs=[top_in],
outputs=[top_out],
value_info=value_info,
nodes=[
helper.make_node("Conv", ["top_in", "p1"], ["top_out"], **conv_config)
],
)
)
model = ModelWrapper(modelproto)
model.set_tensor_datatype("top_in", idt)
model.set_tensor_datatype("top_out", idt)
model.set_tensor_datatype("p1", conv_weight_dt)
model.set_initializer("p1", gen_finn_dt_tensor(conv_weight_dt, conv_param_shape))
model = model.transform(InferShapes())
model = model.transform(InferDataTypes())
new_model = model.transform(LowerConvsToMatMul())
new_model = new_model.transform(to_hls.InferConvInpGen())
if depthwise is True:
new_model = new_model.transform(to_hls.InferVVAU())
else:
new_model = new_model.transform(to_hls.InferQuantizedStreamingFCLayer())
fc_node = new_model.get_nodes_by_op_type("StreamingFCLayer_Batch")[0]
fc_inst = getCustomOp(fc_node)
mw = fc_inst.get_nodeattr("MW")
mh = fc_inst.get_nodeattr("MH")
pe_cands = list(filter(lambda x: mh % x == 0, range(2, mh + 1)))
simd_cands = list(filter(lambda x: mw % x == 0, range(2, mw + 1)))
fc_inst.set_nodeattr("PE", pe_cands[0])
fc_inst.set_nodeattr("SIMD", simd_cands[0])
new_model = new_model.transform(GiveUniqueNodeNames())
new_model = new_model.transform(InferShapes())
new_model = new_model.transform(InferDataTypes())
if exec_mode == "cppsim":
new_model = new_model.transform(PrepareCppSim())
new_model = new_model.transform(CompileCppSim())
new_model = new_model.transform(SetExecMode("cppsim"))
elif exec_mode == "rtlsim":
new_model = new_model.transform(SetExecMode("rtlsim"))
new_model = new_model.transform(GiveUniqueNodeNames())
new_model = new_model.transform(PrepareIP("xc7z020clg400-1", 5))
new_model = new_model.transform(HLSSynthIP())
new_model = new_model.transform(PrepareRTLSim())
else:
raise Exception("Unknown exec_mode")
x = gen_finn_dt_tensor(idt, input_shape)
inp_dict = {model.graph.input[0].name: x}
assert oxe.compare_execution(model, new_model, inp_dict)
if kernel_size == 1 and stride > 1 and pad == 0:
assert new_model.graph.node[1].op_type == "DownSampler"
if exec_mode == "rtlsim":
node = new_model.get_nodes_by_op_type("DownSampler")[0]
inst = getCustomOp(node)
cycles_rtlsim = inst.get_nodeattr("cycles_rtlsim")
exp_cycles_dict = new_model.analysis(exp_cycles_per_layer)
exp_cycles = exp_cycles_dict[node.name]
assert np.isclose(exp_cycles, cycles_rtlsim, atol=11)
assert exp_cycles != 0
if pad == 1:
padding_node = new_model.get_nodes_by_op_type("FMPadding_Batch")[0]
padding_inst = getCustomOp(padding_node)
assert padding_inst.get_nodeattr("SIMD") == in_chn
if depthwise is True and exec_mode == "rtlsim":
node = new_model.get_nodes_by_op_type("Vector_Vector_Activate_Batch")[0]
inst = getCustomOp(node)
cycles_rtlsim = inst.get_nodeattr("cycles_rtlsim")
exp_cycles_dict = new_model.analysis(exp_cycles_per_layer)
exp_cycles = exp_cycles_dict[node.name]
assert np.isclose(exp_cycles, cycles_rtlsim, atol=11)
assert exp_cycles != 0
def set_up_reference_model(act, idt, wdt, k, ifm_dim, ifm_ch, stride, padding):
# set up reference model consisting of Im2Col + MatMul (+ MultiThreshold)
ofm_ch = ifm_ch
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad=padding)
if act is None:
odt = DataType.INT32
else:
odt = act
out_act = oh.make_tensor_value_info(
"out_act", TensorProto.FLOAT, [1, ofm_dim, ofm_dim, ofm_ch]
)
T = oh.make_tensor_value_info("T", TensorProto.FLOAT, [ofm_ch, 15])
tdt = DataType.INT32
thresh_node = oh.make_node(
"MultiThreshold",
domain="finn",
inputs=["outp", "T"],
outputs=["out_act"],
data_layout="NHWC",
out_dtype=odt.name,
out_scale=1.0,
out_bias=0.0,
)
# set up onnx model
inp = oh.make_tensor_value_info(
"inp", TensorProto.FLOAT, [1, ifm_dim, ifm_dim, ifm_ch]
)
outp = oh.make_tensor_value_info(
"outp", TensorProto.FLOAT, [1, ofm_dim, ofm_dim, ofm_ch]
)
W_sparse = oh.make_tensor_value_info(
"W_sparse", TensorProto.FLOAT, [ifm_ch * k * k, ofm_ch]
)
im2col_node = oh.make_node(
"Im2Col",
domain="finn",
inputs=["inp"],
outputs=["im2col_out"],
kernel_size=k,
stride=stride,
pad_amount=padding,
input_shape="(1, {}, {}, {})".format(ifm_dim, ifm_dim, ifm_ch),
depthwise=1,
)
matmul_node = oh.make_node(
"MatMul", inputs=["im2col_out", "W_sparse"], outputs=["outp"]
)
if act is None:
node_list = [im2col_node, matmul_node]
global_out = outp
value_info = [W_sparse]
else:
node_list = [im2col_node, matmul_node, thresh_node]
global_out = out_act
value_info = [W_sparse, T]
graph = oh.make_graph(
nodes=node_list,
name="lowered_dw_cnv_graph",
inputs=[inp],
outputs=[global_out],
value_info=value_info,
)
model = oh.make_model(graph, producer_name="lowered_dw_cnv-model")
model = ModelWrapper(model)
# initialize model
model.set_tensor_datatype("inp", idt)
model.set_tensor_datatype(model.graph.output[0].name, odt)
model.set_tensor_datatype("W_sparse", wdt)
w_tensor = gen_finn_dt_tensor(wdt, [ofm_ch, 1, k, k])
# create sparse matrix
W_matrix = np.zeros((ofm_ch, ifm_ch, k, k))
for ch in range(ifm_ch):
W_matrix[ch][ch] = w_tensor[ch][0]
W_matrix = W_matrix.astype(np.float32)
W_matrix = W_matrix.transpose(0, 2, 3, 1)
W_matrix = W_matrix.reshape(ofm_ch, ifm_ch * k * k)
model.set_initializer("W_sparse", W_matrix.T)
sparsity = {"dw": {"kernel_shape": k}}
model.set_tensor_sparsity("W_sparse", sparsity)
if act is not None:
(min, max) = calculate_signed_dot_prod_range(idt, wdt, ifm_ch * k * k)
n_steps = odt.get_num_possible_values() - 1
T_values = np.random.randint(min, max - 1, (ofm_ch, n_steps)).astype(np.float32)
# provide non-decreasing thresholds
T_values = np.sort(T_values, axis=1)
model.set_initializer("T", T_values)
model.set_tensor_datatype("T", tdt)
model = model.transform(InferShapes())
return model
def test_move_mul_past_dw_conv(ifm_dim, ifm_ch, k, stride, pad_amt, dw):
if dw == 1:
ofm_ch = ifm_ch
groups = ifm_ch
W_shape = [ofm_ch, 1, k, k]
else:
ofm_ch = ifm_ch + 2
groups = 1
W_shape = [ofm_ch, ifm_ch, k, k]
ofm_dim = compute_conv_output_dim(ifm_dim, k, stride, pad_amt)
# set up onnx model
inp = helper.make_tensor_value_info("inp", TensorProto.FLOAT,
[1, ifm_ch, ifm_dim, ifm_dim])
mul = helper.make_tensor_value_info("mul", TensorProto.FLOAT,
[1, ifm_ch, 1, 1])
W = helper.make_tensor_value_info("W", TensorProto.FLOAT, W_shape)
outp = helper.make_tensor_value_info("outp", TensorProto.FLOAT,
[1, ofm_ch, ofm_dim, ofm_dim])
Mul_node = helper.make_node("Mul", ["inp", "mul"], ["mul_out"])
Conv_node = helper.make_node(
"Conv",
["mul_out", "W"],
["outp"],
group=groups,
kernel_shape=[k, k],
pads=[pad_amt, pad_amt, pad_amt, pad_amt],
strides=[stride, stride],
)
graph = helper.make_graph(
nodes=[Mul_node, Conv_node],
name="mulpastconv_graph",
inputs=[inp],
outputs=[outp],
value_info=[mul, W],
)
model = helper.make_model(graph, producer_name="mulpastconv-model")
model = ModelWrapper(model)
inp_values = gen_finn_dt_tensor(DataType.INT2,
[1, ifm_ch, ifm_dim, ifm_dim])
mul_values = gen_finn_dt_tensor(DataType.INT2, [1, ifm_ch, 1, 1])
W_values = gen_finn_dt_tensor(DataType.INT2, W_shape)
model.set_initializer("W", W_values)
model.set_initializer("mul", mul_values)
model = model.transform(InferShapes())
model = model.transform(InferDataTypes())
idict = {"inp": inp_values}
odict = oxe.execute_onnx(model, idict, True)
out_before = odict["outp"]
# move channelwise multiplication past depthwise conv
model_transformed = model.transform(MoveMulPastDWConv())
odict = oxe.execute_onnx(model_transformed, idict, True)
out_after = odict["outp"]
assert (out_before == out_after).all()
if dw == 0:
assert model.graph.node[0].op_type == model_transformed.graph.node[
0].op_type
assert model.graph.node[1].op_type == model_transformed.graph.node[
1].op_type
else:
assert model.graph.node[0].op_type == model_transformed.graph.node[
1].op_type
assert model.graph.node[1].op_type == model_transformed.graph.node[
0].op_type