lhutton1 commented on a change in pull request #10345:
URL: https://github.com/apache/tvm/pull/10345#discussion_r819504681
##########
File path: python/tvm/relay/op/contrib/ethosu.py
##########
@@ -23,7 +23,7 @@
import tvm # type: ignore
from tvm import relay
-from tvm.relay.expr import Constant, Call # type: ignore
+from tvm.relay.expr import Constant, Call
Review comment:
Nit: I don't think we need to change this
##########
File path: python/tvm/relay/op/contrib/ethosu.py
##########
@@ -1103,7 +1103,10 @@ def is_valid(self):
"""
if not check_valid_dtypes([self.ifm, self.ofm],
supported_dtypes=[np.int8]):
return False
- return True
+ return True # optional_bias_add = (
+
+ # is_op("nn.bias_add")(dense, is_constant()) | dense
+ # )
Review comment:
Nit: remove comments :)
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
Review comment:
Nit: Perhaps we should change this slightly to check the full shape of
the conv2d is what's expected. I think `ifm.shape == [1, 1] + list(ifm_shape)`
should do the trick.
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+
+ # check OFM
+ ofm = op.checked_type
+ assert [ofm.shape[2], ofm.shape[3]] == [1, ofm_channels]
+ # assert list(ofm.shape) == list(expected_ofm_shape)
+ assert str(ofm.dtype) == dtype
+ # assert ofm.shape[3] == ofm_channels
Review comment:
Nit: remove some comments
##########
File path: python/tvm/relay/op/contrib/ethosu.py
##########
@@ -1537,6 +1540,112 @@ def squeeze_pattern():
return is_op("squeeze")(wildcard())
+class FullyConnectedParams:
+ """
+ This class will parse a call to an ethos-u.fully_connected composite
+ function and extract the parameter information.
+ """
+
+ composite_name = "ethos-u.fully_connected"
+
+ @requires_vela
+ def __init__(self, func_body):
+ from tvm.relay.backend.contrib.ethosu.util import QDenseArgs # type:
ignore
+ from tvm.relay.backend.contrib.ethosu.util import BiasAddArgs
+ from tvm.relay.backend.contrib.ethosu.util import RequantArgs
+
+ self.activation = None
+ if str(func_body.op) == "clip":
+ self.activation = func_body
+ requantize_op = self.activation.args[0]
+ else:
+ requantize_op = func_body
+
+ call = requantize_op.args[0]
+ if str(requantize_op.args[0].op) == "nn.bias_add":
+ bias_add = call
+ qnn_dense = call.args[0]
+ else:
+ bias_add = None
+ qnn_dense = call
+
+ # weights & biases are params as they should be constant
+ self.weights = TensorParams(
+ qnn_dense.args[QDenseArgs.WEIGHTS.value],
+ None,
+ qnn_dense.args[QDenseArgs.WEIGHTS_SCALE.value],
+ qnn_dense.args[QDenseArgs.WEIGHTS_ZERO_POINT.value],
+ )
+ self.biases = (
+ TensorParams(
+ bias_add.args[BiasAddArgs.BIASES.value],
+ None,
+ requantize_op.args[RequantArgs.IFM_SCALE.value],
+ requantize_op.args[RequantArgs.IFM_ZERO_POINT.value],
+ )
+ if bias_add
+ else None
+ )
+ self.ifm = TensorParams(
+ qnn_dense.args[QDenseArgs.IFM.value],
+ None,
+ qnn_dense.args[QDenseArgs.IFM_SCALE.value],
+ qnn_dense.args[QDenseArgs.IFM_ZERO_POINT.value],
+ )
+ self.ofm = TensorParams(
+ func_body,
+ None,
+ requantize_op.args[RequantArgs.OFM_SCALE.value],
+ requantize_op.args[RequantArgs.OFM_ZERO_POINT.value],
+ )
+
+ def is_valid(self) -> bool:
+ """
+ Checks whether Fully Connected has compatible attributes with HW
+ """
+
+ def check_weights_fc(weights):
+ """Checks whether weight tensor is compatible with HW"""
+ weights_limit = 127 * 65536
+ # A saturation upper bound check for accumulators
+ weights.values = weights.values - weights.q_params.zero_point
+ axis = 1
+ sum_weights = np.amax(np.sum(np.absolute(weights.values),
axis=axis))
+ if not sum_weights <= weights_limit:
+ return False
+ return True
+
+ if not check_valid_dtypes([self.ifm, self.ofm],
supported_dtypes=[np.int8]):
+ return False
+ if not check_weights_fc(self.weights):
+ return False
+ if not check_bias(self.biases):
+ return False
+ if not check_batch_size(self.ifm):
+ return False
+ # Check input shape
+ if len(self.ifm.shape) < 2:
+ return False
+ if not np.all(np.array(self.ifm.shape[:-1]) == 1):
+ # As we reshape the ifm from
+ # [n0, n1, ... , n_m] to [n0 * n1 * ... * n_{m-1}, n_m]
+ # all except the last dims need to be 1.
+ return False
Review comment:
I don't think we need this due to reasoning in the above comment and
since we already check that the batch size == 1 with `check_batch_size` above
and we know that the ifm must be 2D
##########
File path: python/tvm/relay/op/contrib/ethosu.py
##########
@@ -1537,6 +1540,112 @@ def squeeze_pattern():
return is_op("squeeze")(wildcard())
+class FullyConnectedParams:
+ """
+ This class will parse a call to an ethos-u.fully_connected composite
+ function and extract the parameter information.
+ """
+
+ composite_name = "ethos-u.fully_connected"
+
+ @requires_vela
+ def __init__(self, func_body):
+ from tvm.relay.backend.contrib.ethosu.util import QDenseArgs # type:
ignore
+ from tvm.relay.backend.contrib.ethosu.util import BiasAddArgs
+ from tvm.relay.backend.contrib.ethosu.util import RequantArgs
+
+ self.activation = None
+ if str(func_body.op) == "clip":
+ self.activation = func_body
+ requantize_op = self.activation.args[0]
+ else:
+ requantize_op = func_body
+
+ call = requantize_op.args[0]
+ if str(requantize_op.args[0].op) == "nn.bias_add":
+ bias_add = call
+ qnn_dense = call.args[0]
+ else:
+ bias_add = None
+ qnn_dense = call
+
+ # weights & biases are params as they should be constant
+ self.weights = TensorParams(
+ qnn_dense.args[QDenseArgs.WEIGHTS.value],
+ None,
+ qnn_dense.args[QDenseArgs.WEIGHTS_SCALE.value],
+ qnn_dense.args[QDenseArgs.WEIGHTS_ZERO_POINT.value],
+ )
+ self.biases = (
+ TensorParams(
+ bias_add.args[BiasAddArgs.BIASES.value],
+ None,
+ requantize_op.args[RequantArgs.IFM_SCALE.value],
+ requantize_op.args[RequantArgs.IFM_ZERO_POINT.value],
+ )
+ if bias_add
+ else None
+ )
+ self.ifm = TensorParams(
+ qnn_dense.args[QDenseArgs.IFM.value],
+ None,
+ qnn_dense.args[QDenseArgs.IFM_SCALE.value],
+ qnn_dense.args[QDenseArgs.IFM_ZERO_POINT.value],
+ )
+ self.ofm = TensorParams(
+ func_body,
+ None,
+ requantize_op.args[RequantArgs.OFM_SCALE.value],
+ requantize_op.args[RequantArgs.OFM_ZERO_POINT.value],
+ )
+
+ def is_valid(self) -> bool:
+ """
+ Checks whether Fully Connected has compatible attributes with HW
+ """
+
+ def check_weights_fc(weights):
+ """Checks whether weight tensor is compatible with HW"""
+ weights_limit = 127 * 65536
+ # A saturation upper bound check for accumulators
+ weights.values = weights.values - weights.q_params.zero_point
+ axis = 1
+ sum_weights = np.amax(np.sum(np.absolute(weights.values),
axis=axis))
+ if not sum_weights <= weights_limit:
+ return False
+ return True
+
+ if not check_valid_dtypes([self.ifm, self.ofm],
supported_dtypes=[np.int8]):
+ return False
+ if not check_weights_fc(self.weights):
+ return False
+ if not check_bias(self.biases):
+ return False
+ if not check_batch_size(self.ifm):
+ return False
+ # Check input shape
+ if len(self.ifm.shape) < 2:
+ return False
Review comment:
I think we can just check that the IFM shape == 2, since the tflite
frontend inserts a reshape before qnn.dense which we don't pattern match for,
so the IFM should always have a shape of length 2. Lets also check that the ofm
shape == 2
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+
+ # check OFM
+ ofm = op.checked_type
+ assert [ofm.shape[2], ofm.shape[3]] == [1, ofm_channels]
+ # 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] == 1
+ assert weights_ohwi.shape[2] == 1
+ assert weights_ohwi.shape[3] == ifm_shape[1]
+
+ # Check that scale_bias matches weight tensor
+ assert list(op.args[2].checked_type.shape)[0] == ofm_channels
+
+ # expected_padding = infra.compute_padding_shape(
+ # ifm_shape,
+ # expected_ofm_shape,
+ # (0, 0, 0, 0),
+ # (1, 1),
+ # (1, 1),
+ # (1, 1),
+ # )
Review comment:
Nit: comments
##########
File path: python/tvm/relay/op/contrib/ethosu.py
##########
@@ -1537,6 +1540,112 @@ def squeeze_pattern():
return is_op("squeeze")(wildcard())
+class FullyConnectedParams:
+ """
+ This class will parse a call to an ethos-u.fully_connected composite
+ function and extract the parameter information.
+ """
+
+ composite_name = "ethos-u.fully_connected"
+
+ @requires_vela
+ def __init__(self, func_body):
+ from tvm.relay.backend.contrib.ethosu.util import QDenseArgs # type:
ignore
+ from tvm.relay.backend.contrib.ethosu.util import BiasAddArgs
+ from tvm.relay.backend.contrib.ethosu.util import RequantArgs
+
+ self.activation = None
+ if str(func_body.op) == "clip":
+ self.activation = func_body
+ requantize_op = self.activation.args[0]
+ else:
+ requantize_op = func_body
+
+ call = requantize_op.args[0]
+ if str(requantize_op.args[0].op) == "nn.bias_add":
+ bias_add = call
+ qnn_dense = call.args[0]
+ else:
+ bias_add = None
+ qnn_dense = call
+
+ # weights & biases are params as they should be constant
+ self.weights = TensorParams(
+ qnn_dense.args[QDenseArgs.WEIGHTS.value],
+ None,
+ qnn_dense.args[QDenseArgs.WEIGHTS_SCALE.value],
+ qnn_dense.args[QDenseArgs.WEIGHTS_ZERO_POINT.value],
+ )
+ self.biases = (
+ TensorParams(
+ bias_add.args[BiasAddArgs.BIASES.value],
+ None,
+ requantize_op.args[RequantArgs.IFM_SCALE.value],
+ requantize_op.args[RequantArgs.IFM_ZERO_POINT.value],
+ )
+ if bias_add
+ else None
+ )
+ self.ifm = TensorParams(
+ qnn_dense.args[QDenseArgs.IFM.value],
+ None,
+ qnn_dense.args[QDenseArgs.IFM_SCALE.value],
+ qnn_dense.args[QDenseArgs.IFM_ZERO_POINT.value],
+ )
+ self.ofm = TensorParams(
+ func_body,
+ None,
+ requantize_op.args[RequantArgs.OFM_SCALE.value],
+ requantize_op.args[RequantArgs.OFM_ZERO_POINT.value],
+ )
+
+ def is_valid(self) -> bool:
+ """
+ Checks whether Fully Connected has compatible attributes with HW
+ """
+
+ def check_weights_fc(weights):
+ """Checks whether weight tensor is compatible with HW"""
+ weights_limit = 127 * 65536
+ # A saturation upper bound check for accumulators
+ weights.values = weights.values - weights.q_params.zero_point
+ axis = 1
+ sum_weights = np.amax(np.sum(np.absolute(weights.values),
axis=axis))
+ if not sum_weights <= weights_limit:
+ return False
+ return True
+
+ if not check_valid_dtypes([self.ifm, self.ofm],
supported_dtypes=[np.int8]):
+ return False
+ if not check_weights_fc(self.weights):
+ return False
+ if not check_bias(self.biases):
+ return False
+ if not check_batch_size(self.ifm):
+ return False
+ # Check input shape
+ if len(self.ifm.shape) < 2:
+ return False
+ if not np.all(np.array(self.ifm.shape[:-1]) == 1):
+ # As we reshape the ifm from
+ # [n0, n1, ... , n_m] to [n0 * n1 * ... * n_{m-1}, n_m]
+ # all except the last dims need to be 1.
+ return False
+ return True
+
+
+def qnn_fc_pattern():
+ dense = is_op("qnn.dense")(
+ wildcard(), is_constant(), is_constant(), is_constant(),
is_constant(), is_constant()
+ )
+ optional_bias_add = is_op("nn.bias_add")(dense, is_constant()) | dense
Review comment:
I think this should just be `optional_bias_add =
is_op("nn.bias_add")(dense, is_constant())`
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -18,6 +18,8 @@
import pytest
+from tvm.relay.analysis.analysis import extract_fused_functions
Review comment:
unused import?
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+
+ # check OFM
+ ofm = op.checked_type
+ assert [ofm.shape[2], ofm.shape[3]] == [1, ofm_channels]
+ # 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] == 1
+ assert weights_ohwi.shape[2] == 1
+ assert weights_ohwi.shape[3] == ifm_shape[1]
Review comment:
Nit: we could do this with one assert e.g. `assert list(weights_ohwi) ==
[ofm_channels, 1, 1, ifm_shape[1]`
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+
+ # check OFM
+ ofm = op.checked_type
+ assert [ofm.shape[2], ofm.shape[3]] == [1, ofm_channels]
Review comment:
Same as above, lets alter this to check the whole ofm shape `assert
ofm.shape == ...`
##########
File path: tests/python/contrib/test_ethosu/test_legalize.py
##########
@@ -2346,5 +2348,121 @@ def verify(ext_func):
verify(mod["tvmgen_default_ethos_u_main_0"])
[email protected]("ifm_shape", [(1, 14), (1, 151)])
[email protected]("ofm_channels", [32, 64])
[email protected]("use_bias", [True, False])
[email protected]("activation_function", ["RELU", "NONE"])
+def test_tflite_fully_connected(
+ ifm_shape,
+ ofm_channels,
+ use_bias,
+ activation_function,
+):
+ dtype = "int8"
+
+ def create_tflite_graph():
+ class Model(tf.Module):
+ @tf.function
+ def fully_connected(self, x):
+ bias_shape = ofm_channels
+ bias = tf.constant(np.random.uniform(size=bias_shape),
dtype=tf.float32)
+ w = tf.constant(
+ np.random.uniform(size=[ifm_shape[1], ofm_channels]),
+ dtype=tf.float32,
+ )
+ x = tf.matmul(x, w)
+ if use_bias:
+ x = tf.nn.bias_add(x, bias)
+ if activation_function:
+ x = tf.nn.relu(x)
+ return x
+
+ model = Model()
+ concrete_func = model.fully_connected.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)]
+
+ 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(ext_func):
+ op = ext_func.body.args[0]
+ ofm_channels = op.attrs.ofm_channels
+
+ # check IFM
+ ifm = op.args[0].checked_type
+ assert [ifm.shape[2], ifm.shape[3]] == list(ifm_shape)
+ assert str(ifm.dtype) == dtype
+
+ # check OFM
+ ofm = op.checked_type
+ assert [ofm.shape[2], ofm.shape[3]] == [1, ofm_channels]
+ # 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] == 1
+ assert weights_ohwi.shape[2] == 1
+ assert weights_ohwi.shape[3] == ifm_shape[1]
+
+ # Check that scale_bias matches weight tensor
+ assert list(op.args[2].checked_type.shape)[0] == ofm_channels
+
+ # expected_padding = infra.compute_padding_shape(
+ # ifm_shape,
+ # expected_ofm_shape,
+ # (0, 0, 0, 0),
+ # (1, 1),
+ # (1, 1),
+ # (1, 1),
+ # )
+ assert list(op.attrs.padding) == [0, 0, 0, 0]
Review comment:
Nit: might also be worth checking the op name is an NPU convolution here
as well
--
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]
