[Test] better naming and better test for streaming_fclayer

tests/fpgadataflow/test_layer_streaming_fclayer_batch.py → tests/fpgadataflow/test_fpgadataflow_fclayer.py

-# import onnx
 import numpy as np
 from onnx import TensorProto, helper
 
@@ -7,10 +6,19 @@ from finn.core.datatype import DataType
 from finn.core.modelwrapper import ModelWrapper
 
 
-def test_fclayer_batch():
-    inp = helper.make_tensor_value_info("inp", TensorProto.FLOAT, [1, 2, 8])
-    outp = helper.make_tensor_value_info("outp", TensorProto.FLOAT, [1, 4, 4])
-
+def test_fpgadataflow_fclayer_all_bipolar():
+    mh = 4
+    mw = 4
+    pe = 4
+    simd = 4
+    wmem = mw * mh // (pe * simd)
+    n_thres_steps = 1
+    assert mw * mh == wmem * pe * simd
+    nf = mh // pe
+    tmem = nf
+    sf = mw // simd
+    inp = helper.make_tensor_value_info("inp", TensorProto.FLOAT, [1, sf, simd])
+    outp = helper.make_tensor_value_info("outp", TensorProto.FLOAT, [1, nf, pe])
     FCLayer_node = helper.make_node(
         "StreamingFCLayer_Batch",
         ["inp", "weights", "thresh"],
@@ -18,10 +26,10 @@ def test_fclayer_batch():
         domain="finn",
         backend="fpgadataflow",
         resType="ap_resource_lut()",
-        MW=16,
-        MH=16,
-        SIMD=8,
-        PE=4,
+        MW=mw,
+        MH=mh,
+        SIMD=simd,
+        PE=pe,
         resDataType="Recast<XnorMul>",
     )
 
@@ -31,8 +39,12 @@ def test_fclayer_batch():
         inputs=[inp],
         outputs=[outp],
         value_info=[
-            helper.make_tensor_value_info("weights", TensorProto.FLOAT, [8, 4, 16]),
-            helper.make_tensor_value_info("thresh", TensorProto.FLOAT, [16, 4, 3]),
+            helper.make_tensor_value_info(
+                "weights", TensorProto.FLOAT, [pe, wmem, simd]
+            ),
+            helper.make_tensor_value_info(
+                "thresh", TensorProto.FLOAT, [pe, tmem, n_thres_steps]
+            ),
         ],
     )
 
@@ -45,22 +57,29 @@ def test_fclayer_batch():
     for tensor in graph.output:
         model.set_tensor_datatype(tensor.name, DataType["BIPOLAR"])
 
-    # onnx.save(model.model, "fclayer-model.onnx")
-
     # generate input data
-    input_tensor = np.random.randint(2, size=16)
-    input_tensor = (np.asarray(input_tensor, dtype=np.float32)).reshape(1, 2, 8)
+    x = np.random.randint(2, size=mw)
+    input_tensor = (np.asarray(x, dtype=np.float32)).reshape(1, sf, simd)
     input_dict = {"inp": input_tensor}
 
     # generate weights
-    weights_tensor = np.random.randint(2, size=512)
-    weights_tensor = (np.asarray(weights_tensor, dtype=np.float32)).reshape(8, 4, 16)
+    W = np.random.randint(2, size=(mh, mw))
+    weights_tensor = (np.asarray(W, dtype=np.float32)).reshape(pe, wmem, simd)
     input_dict["weights"] = weights_tensor
 
     # generate threshold activation
-    thresh_tensor = np.random.randint(2, size=192)
-    thresh_tensor = (np.asarray(thresh_tensor, dtype=np.float32)).reshape(16, 4, 3)
+    T = np.zeros(mh)
+    thresh_tensor = (np.asarray(T, dtype=np.float32)).reshape(pe, tmem, n_thres_steps)
     input_dict["thresh"] = thresh_tensor
 
     output_dict = oxe.execute_onnx(model, input_dict)
-    print(output_dict)
+
+    # convert to bipolar values
+    Wb = 2 * W - 1
+    xb = 2 * x - 1
+    yb = np.dot(Wb, xb)
+    yb_t = np.sign(yb)
+    # convert expected output to binary
+    expected = (yb_t + 1) // 2
+
+    assert (output_dict["outp"] == expected).all()