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