def test_fpgadataflow_fclayer_npysim(idt, wdt, act, nf, sf, mw, mh):
if nf == -1:
nf = mh
if sf == -1:
sf = mw
pe = mh // nf
simd = mw // sf
assert mh % pe == 0
assert mw % sf == 0
# generate weights
W = gen_finn_dt_tensor(wdt, (mw, mh))
# generate input data
x = gen_finn_dt_tensor(idt, (1, mw))
if act is None:
# no activation, produce accumulators
T = None
tdt = None
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
odt = DataType.UINT32
else:
odt = DataType.INT32
else:
odt = act
(min, max) = calculate_signed_dot_prod_range(idt, wdt, mw)
n_steps = act.get_num_possible_values() - 1
T = np.random.randint(min, max - 1, (mh, n_steps)).astype(np.float32)
# provide non-decreasing thresholds
T = np.sort(T, axis=1)
# generate thresholds for activation
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
tdt = DataType.UINT32
# bias thresholds to be positive
T = np.ceil((T + mw) / 2)
assert (T >= 0).all()
else:
tdt = DataType.INT32
model = make_single_fclayer_modelwrapper(W, pe, simd, wdt, idt, odt, T, tdt)
model = model.transform(SetExecMode("npysim"))
model = model.transform(CodeGen_npysim())
model = model.transform(Compile())
# prepare input data
input_dict = prepare_inputs(x, idt, wdt)
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
# convert inputs to binary and use xnorpopcountmatmul
y = xp.xnorpopcountmatmul((x + 1) / 2, (W + 1) / 2)
else:
y = np.matmul(x, W)
if T is not None:
y = multithreshold(y, T)
if act == DataType.BIPOLAR:
# binary to bipolar
y = 2 * y - 1
else:
# signed offset
y += act.min()
oshape = model.get_tensor_shape("outp")
y_expected = y.reshape(oshape)
# execute model
y_produced = oxe.execute_onnx(model, input_dict)["outp"]
assert (y_produced.reshape(y_expected.shape) == y_expected).all(), "npysim failed"
def hls_random_mlp_maker(layer_spec):
"""Create an MLP of given specification using HLSCustomOp instances.
Generate random weights/thresholds of appropriate size."""
ret = []
for lyr in layer_spec:
idt = lyr["idt"]
wdt = lyr["wdt"]
mw = lyr["mw"]
mh = lyr["mh"]
act = lyr["act"]
lyr["W"] = gen_finn_dt_tensor(wdt, (mw, mh))
if act is None:
# no activation, produce accumulators
T = None
tdt = None
if wdt == DataType["BIPOLAR"] and idt == DataType["BIPOLAR"]:
odt = DataType["UINT32"]
else:
odt = DataType["INT32"]
else:
odt = act
(min, max) = calculate_signed_dot_prod_range(idt, wdt, mw)
n_steps = act.get_num_possible_values() - 1
T = np.random.randint(min, max - 1,
(mh, n_steps)).astype(np.float32)
# provide non-decreasing thresholds
T = np.sort(T, axis=1)
# generate thresholds for activation
if wdt == DataType["BIPOLAR"] and idt == DataType["BIPOLAR"]:
tdt = DataType["UINT32"]
# bias thresholds to be positive
T = np.ceil((T + mw) / 2)
assert (T >= 0).all()
else:
tdt = DataType["INT32"]
lyr["T"] = T
lyr["tdt"] = tdt
lyr["odt"] = odt
ret.append(lyr)
return hls_mlp_maker(ret)
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.custom_op.general",
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.custom_op.general",
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_fpgadataflow_fclayer_large_depth_decoupled_mode_rtlsim(
mem_mode, idt, wdt, act, nf, sf, mw, mh):
if nf == -1:
nf = mh
if sf == -1:
sf = mw
pe = mh // nf
simd = mw // sf
assert mh % pe == 0
assert mw % sf == 0
# generate weights
W = gen_finn_dt_tensor(wdt, (mw, mh))
# generate input data
x = gen_finn_dt_tensor(idt, (1, mw))
if act is None:
# no activation, produce accumulators
T = None
tdt = None
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
odt = DataType.UINT32
else:
odt = DataType.INT32
else:
odt = act
(min, max) = calculate_signed_dot_prod_range(idt, wdt, mw)
n_steps = act.get_num_possible_values() - 1
T = np.random.randint(min, max - 1, (mh, n_steps)).astype(np.float32)
# provide non-decreasing thresholds
T = np.sort(T, axis=1)
# generate thresholds for activation
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
tdt = DataType.UINT32
# bias thresholds to be positive
T = np.ceil((T + mw) / 2)
assert (T >= 0).all()
else:
tdt = DataType.INT32
model = make_single_fclayer_modelwrapper(W, pe, simd, wdt, idt, odt, T,
tdt)
for node in model.graph.node:
# lookup op_type in registry of CustomOps
inst = getCustomOp(node)
inst.set_nodeattr("mem_mode", mem_mode)
# prepare input data
input_dict = prepare_inputs(x, idt, wdt)
if wdt == DataType.BIPOLAR and idt == DataType.BIPOLAR:
# convert inputs to binary and use xnorpopcountmatmul
y = xp.xnorpopcountmatmul((x + 1) / 2, (W + 1) / 2)
else:
y = np.matmul(x, W)
if T is not None:
y = multithreshold(y, T)
if act == DataType.BIPOLAR:
# binary to bipolar
y = 2 * y - 1
else:
# signed offset
y += act.min()
oshape = model.get_tensor_shape("outp")
y_expected = y.reshape(oshape)
# TODO split up into several dependent tests -- need to check how this
# works for parametrized tests...
model = model.transform(SetExecMode("rtlsim"))
model = model.transform(GiveUniqueNodeNames())
model = model.transform(PrepareIP("xc7z020clg400-1", 5))
model = model.transform(HLSSynthIP())
model = model.transform(PrepareRTLSim())
y_produced = oxe.execute_onnx(model, input_dict)["outp"]
assert (y_produced.reshape(
y_expected.shape) == y_expected).all(), "rtlsim failed"
hls_synt_res_est = model.analysis(hls_synth_res_estimation)
assert "StreamingFCLayer_Batch_0" in hls_synt_res_est
node = model.get_nodes_by_op_type("StreamingFCLayer_Batch")[0]
inst = getCustomOp(node)
cycles_rtlsim = inst.get_nodeattr("cycles_rtlsim")
exp_cycles_dict = model.analysis(exp_cycles_per_layer)
exp_cycles = exp_cycles_dict[node.name]
assert np.isclose(exp_cycles, cycles_rtlsim, atol=15)
assert exp_cycles != 0
def create_two_fc_model():
# create a model with two StreamingFCLayer instances
wdt = DataType.INT2
idt = DataType.INT2
odt = DataType.INT2
act = DataType.INT2
m = 4
tdt = DataType.INT32
actval = odt.min()
no_act = 0
binary_xnor_mode = 0
pe = 2
simd = 2
inp = helper.make_tensor_value_info("inp", TensorProto.FLOAT, [1, m])
mid = helper.make_tensor_value_info("mid", TensorProto.FLOAT, [1, m])
outp = helper.make_tensor_value_info("outp", TensorProto.FLOAT, [1, m])
fc0 = helper.make_node(
"StreamingFCLayer_Batch",
["inp", "w0", "t0"],
["mid"],
domain="finn",
backend="fpgadataflow",
resType="ap_resource_lut()",
MW=m,
MH=m,
SIMD=simd,
PE=pe,
inputDataType=idt.name,
weightDataType=wdt.name,
outputDataType=odt.name,
ActVal=actval,
binaryXnorMode=binary_xnor_mode,
noActivation=no_act,
)
fc1 = helper.make_node(
"StreamingFCLayer_Batch",
["mid", "w1", "t1"],
["outp"],
domain="finn",
backend="fpgadataflow",
resType="ap_resource_lut()",
MW=m,
MH=m,
SIMD=simd,
PE=pe,
inputDataType=idt.name,
weightDataType=wdt.name,
outputDataType=odt.name,
ActVal=actval,
binaryXnorMode=binary_xnor_mode,
noActivation=no_act,
)
graph = helper.make_graph(
nodes=[fc0, fc1],
name="fclayer_graph",
inputs=[inp],
outputs=[outp],
value_info=[mid],
)
model = helper.make_model(graph, producer_name="fclayer-model")
model = ModelWrapper(model)
model.set_tensor_datatype("inp", idt)
model.set_tensor_datatype("mid", idt)
model.set_tensor_datatype("outp", odt)
model.set_tensor_datatype("w0", wdt)
model.set_tensor_datatype("w1", wdt)
# generate weights
w0 = gen_finn_dt_tensor(wdt, (m, m))
w1 = gen_finn_dt_tensor(wdt, (m, m))
model.set_initializer("w0", w0)
model.set_initializer("w1", w1)
# generate thresholds
(min, max) = calculate_signed_dot_prod_range(idt, wdt, m)
n_steps = act.get_num_possible_values() - 1
t0 = np.random.randint(min, max - 1, (m, n_steps)).astype(np.float32)
t1 = np.random.randint(min, max - 1, (m, n_steps)).astype(np.float32)
# provide non-decreasing thresholds
t0 = np.sort(t0, axis=1)
t1 = np.sort(t1, axis=1)
model.set_initializer("t0", t0)
model.set_initializer("t1", t1)
model.set_tensor_datatype("t0", tdt)
model.set_tensor_datatype("t1", tdt)
return model