ekalda commented on a change in pull request #9508:
URL: https://github.com/apache/tvm/pull/9508#discussion_r749377001
##########
File path: tests/python/contrib/test_ethosu/test_codegen.py
##########
@@ -48,122 +47,147 @@ def get_shape_expr(in_expr, out_expr):
return shape
[email protected](
- "accel_type",
- ACCEL_TYPES,
-)
-def test_ethosu_conv2d(accel_type):
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.kernel.sc = relay.const(np.random.rand(32) * 2, "float32")
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("accel_type", ACCEL_TYPES)
Review comment:
It would be good to test different dilations, strides and ReLU
activation as well
##########
File path: tests/python/contrib/test_ethosu/test_codegen.py
##########
@@ -48,122 +47,147 @@ def get_shape_expr(in_expr, out_expr):
return shape
[email protected](
- "accel_type",
- ACCEL_TYPES,
-)
-def test_ethosu_conv2d(accel_type):
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.kernel.sc = relay.const(np.random.rand(32) * 2, "float32")
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
Review comment:
Since in the rest of the NPU code "kernel shape" refers to the 2
dimensional height and width of the weights/kernel, I think it would be good to
follow the same convention here, especially since it is not obvious from the 4D
array what each number represents. I suggest you pass in the kernel shape as a
2D array and either have separate parameters for input/output channels or
define them in the test body and use the same input and output channels for
each test
##########
File path: tests/python/contrib/test_ethosu/test_codegen.py
##########
@@ -48,122 +47,147 @@ def get_shape_expr(in_expr, out_expr):
return shape
[email protected](
- "accel_type",
- ACCEL_TYPES,
-)
-def test_ethosu_conv2d(accel_type):
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.kernel.sc = relay.const(np.random.rand(32) * 2, "float32")
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("accel_type", ACCEL_TYPES)
+def test_ethosu_conv2d(ifm_shape, kernel_shape, padding, accel_type):
+ dtype = "int8"
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2_params.update_output_qnn_params()
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
-
- def create_graph_activation(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 90
- c1_params.clip_max = 110
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
+ def create_tflite_graph_single():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function(self, x):
+ # Use tf.nn API to create the model
+ op = tf.nn.conv2d(
+ x,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=1,
+ )
+ return op
Review comment:
This function should optionally create a graph of conv2d followed by ReLU
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -221,135 +221,135 @@ def get_shape_expr(in_expr, out_expr):
return shape
+def compute_ofm_shape(ifm_shape, padding, kernel_shape, strides, dilation):
+ if padding.lower() == "valid":
+ h = math.ceil((ifm_shape[1] - (kernel_shape[0] - 1) * dilation[0]) /
strides[0])
+ w = math.ceil((ifm_shape[2] - (kernel_shape[1] - 1) * dilation[1]) /
strides[1])
+ if padding.lower() == "same":
+ h = math.ceil(ifm_shape[1] / strides[0])
+ w = math.ceil(ifm_shape[2] / strides[1])
+ ofm_shape = [ifm_shape[0], h, w, kernel_shape[3]]
+ return ofm_shape
+
+
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP = {
"HWIO": [1, 2, 3, 0],
"HWOI": [1, 2, 0, 3],
"OWHI": [0, 1, 2, 3],
}
-def test_ethosu_conv2d_legalize():
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 10
- c1_params.clip_max = 240
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("strides, dilation", [((1, 1), (2, 1)), ((3, 2), (1,
1))])
[email protected]("activation", [None, None])
+def test_tflite_conv_2d_legalize(ifm_shape, kernel_shape, padding, strides,
dilation, activation):
+ dtype = "int8"
+
+ def create_tflite_graph_single():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function(self, input_shape):
+ op = tf.nn.conv2d(
+ input_shape,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=strides,
+ padding=padding,
+ data_format="NHWC",
+ dilations=dilation,
+ )
+ if activation:
+ op = tf.nn.relu(op)
+ return op
+
+ model = Model()
+ concrete_func = model.tf_function.get_concrete_function(
+ tf.TensorSpec(ifm_shape, dtype=tf.float32)
+ )
+ # Convert the model
+ def representative_dataset():
+ for _ in range(100):
+ data = np.random.rand(*tuple(ifm_shape))
+ yield [data.astype(np.float32)]
- def verify_tensor(tensor_type, expr):
- assert list(tensor_type.shape) == list(expr.checked_type.shape)
- assert str(tensor_type.dtype) == str(expr.checked_type.dtype)
+ converter =
tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
+ converter.optimizations = [tf.lite.Optimize.DEFAULT]
+ converter.representative_dataset = representative_dataset
+ converter.target_spec.supported_ops =
[tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+ converter.inference_input_type = tf.int8
+ converter.inference_output_type = tf.int8
+ tflite_model = converter.convert()
+ return tflite_model
- def verify_linear(ext_func, conv2d_params):
+ def verify(ext_func):
op = ext_func.body
- for param in conv2d_params:
- verify_tensor(param.ifm, op.args[0])
- verify_tensor(param.ofm, op)
-
- # This will be in OHWI layout
- weights_ohwi = op.args[1].data.asnumpy()
- weights_layout = str(param.kernel.layout)
- weights = np.transpose(weights_ohwi,
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP[weights_layout])
- assert weights.shape == param.kernel.shape
- assert weights.dtype == param.kernel.dtype
-
- assert list(op.args[2].checked_type.shape)[0] ==
weights_ohwi.shape[0]
-
- assert float(op.attrs.ifm_scale) ==
float(param.ifm.sc.data.asnumpy())
- assert int(op.attrs.ifm_zero_point) ==
int(param.ifm.zp.data.asnumpy())
- assert int(op.attrs.weight_zero_point) ==
int(param.kernel.zp.data.asnumpy())
- assert float(op.attrs.ofm_scale) ==
float(param.ofm.sc.data.asnumpy())
- assert int(op.attrs.ofm_zero_point) ==
int(param.ofm.zp.data.asnumpy())
- assert int(op.attrs.ofm_channels) == int(weights_ohwi.shape[0])
- assert list(op.attrs.padding) == list(param.pad)
- assert list(op.attrs.strides) == list(param.strides)
- assert list(op.attrs.dilation) == list(param.dilation)
- assert str(op.attrs.activation) == str(param.activation)
- assert int(op.attrs.clip_min) == int(param.clip_min)
- assert int(op.attrs.clip_max) == int(param.clip_max)
- op = op.args[0]
-
- test_cases = [
- (create_graph_single, ["input", (1, 299, 299, 3), "uint8"]),
- (create_graph_double, ["input", (1, 128, 256, 4), "uint8"]),
- ]
- for test_case in test_cases:
- mod, conv_params = test_case[0](*test_case[1])
- mod = ethosu.partition_for_ethosu(mod)
- mod = legalize.LegalizeConv2D()(mod)
- verify_linear(mod["tvmgen_default_ethos_u_main_0"], conv_params)
-
-
-def test_ethosu_conv2d_legalize_errors():
- def create_graph_single_unsupported_ifm_layout(
- input_tensor_name, input_tensor_shape, input_tensor_dtype
- ):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.ifm.layout = "NCHW"
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[1], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert list(ifm.shape) == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+ assert ifm.shape[3] == ofm_channels
+
+ # check OFM
+ ofm = op.checked_type
+ expected_ofm_shape = compute_ofm_shape(ifm_shape, padding,
kernel_shape, strides, dilation)
+ assert list(ofm.shape) == list(expected_ofm_shape)
+ assert str(ofm.dtype) == dtype
+ assert ofm.shape[3] == ofm_channels
+
+ # check weights
+ weights_ohwi = op.args[1].data.asnumpy()
+ assert str(weights_ohwi.dtype) == dtype
+ assert weights_ohwi.shape[0] == ofm_channels
+ assert weights_ohwi.shape[1] == kernel_shape[0]
+ assert weights_ohwi.shape[2] == kernel_shape[1]
+ assert weights_ohwi.shape[3] == 3 # only depth multiplier 1 is
supported
+
+ # Check that scale_bias matches weight tensor
+ assert list(op.args[2].checked_type.shape)[0] == ofm_channels
- test_cases = [
- (create_graph_single_unsupported_ifm_layout, ["input", (1, 3, 299,
299), "uint8"]),
+ expected_padding = infra.compute_padding_shape(
+ ifm_shape,
+ expected_ofm_shape,
+ padding,
+ (kernel_shape[0], kernel_shape[1]),
+ strides,
+ dilation,
+ )
+ assert list(op.attrs.padding) == list(expected_padding)
+ assert op.attrs.ofm_channels == ofm_channels
Review comment:
Since it was defined previously that `ofm_channels =
op.attrs.ofm_channels`, this assert will never fail
##########
File path: tests/python/contrib/test_ethosu/test_codegen.py
##########
@@ -48,122 +47,147 @@ def get_shape_expr(in_expr, out_expr):
return shape
[email protected](
- "accel_type",
- ACCEL_TYPES,
-)
-def test_ethosu_conv2d(accel_type):
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.kernel.sc = relay.const(np.random.rand(32) * 2, "float32")
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("accel_type", ACCEL_TYPES)
+def test_ethosu_conv2d(ifm_shape, kernel_shape, padding, accel_type):
+ dtype = "int8"
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2_params.update_output_qnn_params()
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
-
- def create_graph_activation(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 90
- c1_params.clip_max = 110
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
+ def create_tflite_graph_single():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function(self, x):
+ # Use tf.nn API to create the model
+ op = tf.nn.conv2d(
+ x,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=1,
+ )
+ return op
+
+ model = Model()
+ concrete_func = model.tf_function.get_concrete_function(
+ tf.TensorSpec(ifm_shape, dtype=tf.float32)
)
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2_params.update_output_qnn_params()
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
-
- test_cases = [
- (create_graph_single, ["input", (1, 300, 300, 3), "int8"]),
- (create_graph_double, ["input", (1, 128, 256, 4), "int8"]),
- (create_graph_activation, ["input", (1, 64, 100, 4), "int8"]),
- ]
- np.random.seed(42)
- for test_case in test_cases:
- relay_module, conv_params = test_case[0](*test_case[1])
- input_tensor, input_shape, input_dtype = test_case[1]
- mod = partition_for_ethosu(relay_module)
-
- # Generate reference data
- in_min, in_max = util.get_range_for_dtype_str(input_dtype)
- input_data = {
- input_tensor: np.random.randint(
- in_min, high=in_max, size=input_shape, dtype=input_dtype
- )
- }
- output_data = generate_ref_data(relay_module, input_data)
-
- compiled_models = infra.build_source(
- mod, input_data, output_data, accel_type, output_tolerance=1
+
+ # Convert the model
+ def representative_dataset():
+ for _ in range(100):
+ data = np.random.rand(*tuple(ifm_shape))
+ yield [data.astype(np.float32)]
+
+ converter =
tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
+ converter.optimizations = [tf.lite.Optimize.DEFAULT]
+ converter.representative_dataset = representative_dataset
+ converter.target_spec.supported_ops =
[tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+ converter.inference_input_type = tf.int8
+ converter.inference_output_type = tf.int8
+ tflite_model = converter.convert()
+ return tflite_model
+
+ def create_tflite_graph_double():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function_double(self, x):
+ # Use tf.nn API to create the model with two convolutions
+ op = tf.nn.conv2d(
+ x,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=1,
+ )
+ # Second convolution
+ op2 = tf.nn.conv2d(
+ op,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=2,
+ )
+ return op2
Review comment:
Same as before - it would be good to test ReLU here as well
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -221,135 +221,135 @@ def get_shape_expr(in_expr, out_expr):
return shape
+def compute_ofm_shape(ifm_shape, padding, kernel_shape, strides, dilation):
+ if padding.lower() == "valid":
+ h = math.ceil((ifm_shape[1] - (kernel_shape[0] - 1) * dilation[0]) /
strides[0])
+ w = math.ceil((ifm_shape[2] - (kernel_shape[1] - 1) * dilation[1]) /
strides[1])
+ if padding.lower() == "same":
+ h = math.ceil(ifm_shape[1] / strides[0])
+ w = math.ceil(ifm_shape[2] / strides[1])
+ ofm_shape = [ifm_shape[0], h, w, kernel_shape[3]]
+ return ofm_shape
+
+
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP = {
"HWIO": [1, 2, 3, 0],
"HWOI": [1, 2, 0, 3],
"OWHI": [0, 1, 2, 3],
}
-def test_ethosu_conv2d_legalize():
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 10
- c1_params.clip_max = 240
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("strides, dilation", [((1, 1), (2, 1)), ((3, 2), (1,
1))])
[email protected]("activation", [None, None])
Review comment:
```suggestion
@pytest.mark.parametrize("activation", [None, RELU])
```
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -221,135 +221,135 @@ def get_shape_expr(in_expr, out_expr):
return shape
+def compute_ofm_shape(ifm_shape, padding, kernel_shape, strides, dilation):
+ if padding.lower() == "valid":
+ h = math.ceil((ifm_shape[1] - (kernel_shape[0] - 1) * dilation[0]) /
strides[0])
+ w = math.ceil((ifm_shape[2] - (kernel_shape[1] - 1) * dilation[1]) /
strides[1])
+ if padding.lower() == "same":
+ h = math.ceil(ifm_shape[1] / strides[0])
+ w = math.ceil(ifm_shape[2] / strides[1])
+ ofm_shape = [ifm_shape[0], h, w, kernel_shape[3]]
+ return ofm_shape
+
+
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP = {
"HWIO": [1, 2, 3, 0],
"HWOI": [1, 2, 0, 3],
"OWHI": [0, 1, 2, 3],
}
-def test_ethosu_conv2d_legalize():
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 10
- c1_params.clip_max = 240
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
Review comment:
Same concern about mysterious 4 numbers as before :)
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -221,135 +221,135 @@ def get_shape_expr(in_expr, out_expr):
return shape
+def compute_ofm_shape(ifm_shape, padding, kernel_shape, strides, dilation):
+ if padding.lower() == "valid":
+ h = math.ceil((ifm_shape[1] - (kernel_shape[0] - 1) * dilation[0]) /
strides[0])
+ w = math.ceil((ifm_shape[2] - (kernel_shape[1] - 1) * dilation[1]) /
strides[1])
+ if padding.lower() == "same":
+ h = math.ceil(ifm_shape[1] / strides[0])
+ w = math.ceil(ifm_shape[2] / strides[1])
+ ofm_shape = [ifm_shape[0], h, w, kernel_shape[3]]
+ return ofm_shape
+
+
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP = {
"HWIO": [1, 2, 3, 0],
"HWOI": [1, 2, 0, 3],
"OWHI": [0, 1, 2, 3],
}
-def test_ethosu_conv2d_legalize():
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 10
- c1_params.clip_max = 240
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("strides, dilation", [((1, 1), (2, 1)), ((3, 2), (1,
1))])
[email protected]("activation", [None, None])
+def test_tflite_conv_2d_legalize(ifm_shape, kernel_shape, padding, strides,
dilation, activation):
+ dtype = "int8"
+
+ def create_tflite_graph_single():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function(self, input_shape):
+ op = tf.nn.conv2d(
+ input_shape,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=strides,
+ padding=padding,
+ data_format="NHWC",
+ dilations=dilation,
+ )
+ if activation:
+ op = tf.nn.relu(op)
+ return op
+
+ model = Model()
+ concrete_func = model.tf_function.get_concrete_function(
+ tf.TensorSpec(ifm_shape, dtype=tf.float32)
+ )
+ # Convert the model
+ def representative_dataset():
+ for _ in range(100):
+ data = np.random.rand(*tuple(ifm_shape))
+ yield [data.astype(np.float32)]
- def verify_tensor(tensor_type, expr):
- assert list(tensor_type.shape) == list(expr.checked_type.shape)
- assert str(tensor_type.dtype) == str(expr.checked_type.dtype)
+ converter =
tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
+ converter.optimizations = [tf.lite.Optimize.DEFAULT]
+ converter.representative_dataset = representative_dataset
+ converter.target_spec.supported_ops =
[tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+ converter.inference_input_type = tf.int8
+ converter.inference_output_type = tf.int8
+ tflite_model = converter.convert()
+ return tflite_model
- def verify_linear(ext_func, conv2d_params):
+ def verify(ext_func):
op = ext_func.body
- for param in conv2d_params:
- verify_tensor(param.ifm, op.args[0])
- verify_tensor(param.ofm, op)
-
- # This will be in OHWI layout
- weights_ohwi = op.args[1].data.asnumpy()
- weights_layout = str(param.kernel.layout)
- weights = np.transpose(weights_ohwi,
INVERSE_LAYOUT_TRANSFORM_OHWI_MAP[weights_layout])
- assert weights.shape == param.kernel.shape
- assert weights.dtype == param.kernel.dtype
-
- assert list(op.args[2].checked_type.shape)[0] ==
weights_ohwi.shape[0]
-
- assert float(op.attrs.ifm_scale) ==
float(param.ifm.sc.data.asnumpy())
- assert int(op.attrs.ifm_zero_point) ==
int(param.ifm.zp.data.asnumpy())
- assert int(op.attrs.weight_zero_point) ==
int(param.kernel.zp.data.asnumpy())
- assert float(op.attrs.ofm_scale) ==
float(param.ofm.sc.data.asnumpy())
- assert int(op.attrs.ofm_zero_point) ==
int(param.ofm.zp.data.asnumpy())
- assert int(op.attrs.ofm_channels) == int(weights_ohwi.shape[0])
- assert list(op.attrs.padding) == list(param.pad)
- assert list(op.attrs.strides) == list(param.strides)
- assert list(op.attrs.dilation) == list(param.dilation)
- assert str(op.attrs.activation) == str(param.activation)
- assert int(op.attrs.clip_min) == int(param.clip_min)
- assert int(op.attrs.clip_max) == int(param.clip_max)
- op = op.args[0]
-
- test_cases = [
- (create_graph_single, ["input", (1, 299, 299, 3), "uint8"]),
- (create_graph_double, ["input", (1, 128, 256, 4), "uint8"]),
- ]
- for test_case in test_cases:
- mod, conv_params = test_case[0](*test_case[1])
- mod = ethosu.partition_for_ethosu(mod)
- mod = legalize.LegalizeConv2D()(mod)
- verify_linear(mod["tvmgen_default_ethos_u_main_0"], conv_params)
-
-
-def test_ethosu_conv2d_legalize_errors():
- def create_graph_single_unsupported_ifm_layout(
- input_tensor_name, input_tensor_shape, input_tensor_dtype
- ):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.ifm.layout = "NCHW"
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[1], 32)
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 23
- c1_params.clip_max = 180
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert list(ifm.shape) == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+ assert ifm.shape[3] == ofm_channels
+
+ # check OFM
+ ofm = op.checked_type
+ expected_ofm_shape = compute_ofm_shape(ifm_shape, padding,
kernel_shape, strides, dilation)
+ assert list(ofm.shape) == list(expected_ofm_shape)
+ assert str(ofm.dtype) == dtype
+ assert ofm.shape[3] == ofm_channels
+
+ # check weights
+ weights_ohwi = op.args[1].data.asnumpy()
+ assert str(weights_ohwi.dtype) == dtype
+ assert weights_ohwi.shape[0] == ofm_channels
+ assert weights_ohwi.shape[1] == kernel_shape[0]
+ assert weights_ohwi.shape[2] == kernel_shape[1]
+ assert weights_ohwi.shape[3] == 3 # only depth multiplier 1 is
supported
Review comment:
"only depth multiplier 1 is supported" is true for depthwise
convolution, but not for "normal" convolution
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -221,135 +221,135 @@ def get_shape_expr(in_expr, out_expr):
return shape
+def compute_ofm_shape(ifm_shape, padding, kernel_shape, strides, dilation):
+ if padding.lower() == "valid":
+ h = math.ceil((ifm_shape[1] - (kernel_shape[0] - 1) * dilation[0]) /
strides[0])
+ w = math.ceil((ifm_shape[2] - (kernel_shape[1] - 1) * dilation[1]) /
strides[1])
+ if padding.lower() == "same":
+ h = math.ceil(ifm_shape[1] / strides[0])
+ w = math.ceil(ifm_shape[2] / strides[1])
+ ofm_shape = [ifm_shape[0], h, w, kernel_shape[3]]
+ return ofm_shape
Review comment:
There is an identical function with the same name infra.py, you should
use that one
##########
File path: tests/python/contrib/test_ethosu/test_codegen.py
##########
@@ -48,122 +46,147 @@ def get_shape_expr(in_expr, out_expr):
return shape
[email protected](
- "accel_type",
- ACCEL_TYPES,
-)
-def test_ethosu_conv2d(accel_type):
- def create_graph_single(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (3, 3, c1_params.ifm.shape[3], 32)
- c1_params.kernel.sc = relay.const(np.random.rand(32) * 2, "float32")
- c1_params.strides = (1, 1)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
[email protected]("ifm_shape", [(1, 299, 299, 3), (1, 55, 55, 3)])
[email protected]("kernel_shape", [(3, 2, 3, 3), (1, 3, 3, 3)])
[email protected]("padding", ["SAME", "VALID"])
[email protected]("accel_type", ACCEL_TYPES)
+def test_ethosu_conv2d(ifm_shape, kernel_shape, padding, accel_type):
+ dtype = "int8"
- f = relay.Function([input0], c1)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c1_params]
-
- def create_graph_double(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
- )
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2_params.update_output_qnn_params()
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
-
- def create_graph_activation(input_tensor_name, input_tensor_shape,
input_tensor_dtype):
- c1_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c1_params.ifm.shape = input_tensor_shape
- c1_params.kernel.shape = (7, 7, c1_params.ifm.shape[3], 8)
- c1_params.strides = (2, 2)
- c1_params.pad = "VALID"
- c1_params.activation = "CLIP"
- c1_params.clip_min = 90
- c1_params.clip_max = 110
- c1_params.update_output_qnn_params(
- input_tensor_dtype, input_tensor_dtype, input_tensor_dtype
+ def create_tflite_graph_single():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function(self, x):
+ # Use tf.nn API to create the model
+ op = tf.nn.conv2d(
+ x,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=1,
+ )
+ return op
+
+ model = Model()
+ concrete_func = model.tf_function.get_concrete_function(
+ tf.TensorSpec(ifm_shape, dtype=tf.float32)
)
- input0 = relay.var(input_tensor_name, shape=c1_params.ifm.shape,
dtype=c1_params.ifm.dtype)
- c1, new_params = relay_ir_builder.create_qnn_conv2d(c1_params, input0)
- c1_params.ofm.shape = get_shape_expr(input0, c1)
-
- c2_params = relay_ir_builder.QnnConv2DParams(input_tensor_dtype)
- c2_params.ifm.shape = c1_params.ofm.shape
- c2_params.kernel.shape = (5, 5, c2_params.ifm.shape[3], 16)
- c2_params.strides = (1, 1)
- c2_params.pad = "SAME"
- c2_params.update_output_qnn_params()
- c2, new_params = relay_ir_builder.create_qnn_conv2d(c2_params, c1)
- c2_params.ofm.shape = get_shape_expr(input0, c2)
-
- f = relay.Function([input0], c2)
- mod = tvm.IRModule()
- mod["main"] = f
- return mod, [c2_params, c1_params]
-
- test_cases = [
- (create_graph_single, ["input", (1, 300, 300, 3), "int8"]),
- (create_graph_double, ["input", (1, 128, 256, 4), "int8"]),
- (create_graph_activation, ["input", (1, 64, 100, 4), "int8"]),
- ]
- np.random.seed(42)
- for test_case in test_cases:
- relay_module, conv_params = test_case[0](*test_case[1])
- input_tensor, input_shape, input_dtype = test_case[1]
- mod = partition_for_ethosu(relay_module)
-
- # Generate reference data
- in_min, in_max = util.get_range_for_dtype_str(input_dtype)
- input_data = {
- input_tensor: np.random.randint(
- in_min, high=in_max, size=input_shape, dtype=input_dtype
- )
- }
- output_data = generate_ref_data(relay_module, input_data)
-
- compiled_models = infra.build_source(
- mod, input_data, output_data, accel_type, output_tolerance=1
+
+ # Convert the model
+ def representative_dataset():
+ for _ in range(100):
+ data = np.random.rand(*tuple(ifm_shape))
+ yield [data.astype(np.float32)]
+
+ converter =
tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
+ converter.optimizations = [tf.lite.Optimize.DEFAULT]
+ converter.representative_dataset = representative_dataset
+ converter.target_spec.supported_ops =
[tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+ converter.inference_input_type = tf.int8
+ converter.inference_output_type = tf.int8
+ tflite_model = converter.convert()
+ return tflite_model
+
+ def create_tflite_graph_double():
+ class Model(tf.Module):
+ @tf.function
+ def tf_function_double(self, x):
+ # Use tf.nn API to create the model with two convolutions
+ op = tf.nn.conv2d(
+ x,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=1,
+ )
+ # Second convolution
+ op2 = tf.nn.conv2d(
+ op,
+ filters=tf.constant(np.random.uniform(size=kernel_shape),
dtype=tf.float32),
+ strides=(1, 1),
+ padding=padding,
+ data_format="NHWC",
+ dilations=2,
+ )
+ return op2
+
+ model = Model()
+ concrete_func = model.tf_function_double.get_concrete_function(
+ tf.TensorSpec(ifm_shape, dtype=tf.float32)
)
- # Assumes only two runtime.Modules are created -- i.e. single offload
module
- imported_modules =
compiled_models[0].executor_factory.lib.imported_modules
- assert len(imported_modules) == 2
- ethosu_module = imported_modules[0]
-
- # Verify generated C source
- get_cs = tvm._ffi.get_global_func("runtime.module.ethosu.getcs")
- cmms = get_cs(ethosu_module)
- cmms = bytes.fromhex(cmms)
- infra.print_payload(cmms)
- infra.verify_source(compiled_models, accel_type)
+ # Convert the model
+ def representative_dataset():
+ for _ in range(100):
+ data = np.random.rand(*tuple(ifm_shape))
+ yield [data.astype(np.float32)]
+
+ converter =
tf.lite.TFLiteConverter.from_concrete_functions([concrete_func])
+ converter.optimizations = [tf.lite.Optimize.DEFAULT]
+ converter.representative_dataset = representative_dataset
+ converter.target_spec.supported_ops =
[tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+ converter.inference_input_type = tf.int8
+ converter.inference_output_type = tf.int8
+ tflite_model = converter.convert()
+ return tflite_model
+
+ tflite_graph_single = create_tflite_graph_single()
+ tflite_model_single =
tflite.Model.Model.GetRootAsModel(tflite_graph_single, 0)
+
+ tflite_graph_double = create_tflite_graph_double()
+ tflite_model_double =
tflite.Model.Model.GetRootAsModel(tflite_graph_double, 0)
Review comment:
Wouldn't it make more sense to have single and double graphs as separate
tests with their own parameters? Currently, if that test fails, it is not
immediately obvious whether it was the single or double graph test that failed
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
