def test_invalid_parameters(
op,
input_dtype,
):
input_scale = 0.256
input_zero_point = 33
model = make_model(
op,
[1, 16, 16, 3],
input_dtype,
input_dtype,
input_scale,
input_zero_point,
input_scale,
input_zero_point,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert not any(attrs), "No function should have an external attribute."
def test_op_int8(zero_point, scale):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_USMP_CORSTONE300_RUNNER
dtype = "int8"
shape = [1, 16, 16, 3]
model = make_model(shape, dtype, dtype, zero_point, scale)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
in_min, in_max = get_range_for_dtype_str(dtype)
np.random.seed(0)
input_data = np.random.randint(in_min,
high=in_max,
size=shape,
dtype=dtype)
inputs = {"in0": input_data}
params = {}
output_list = generate_ref_data(orig_mod["main"], inputs, params)
compile_and_run(
AOTTestModel(module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=params),
test_runner,
interface_api,
use_unpacked_api,
)
def test_invalid_parameters(in_dtype, out_dtype, zero_point, scale,
out_zero_point, out_scale):
model = make_model([1, 16, 16, 3], in_dtype, out_dtype, zero_point, scale,
out_zero_point, out_scale)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_invalid_batch_size(op):
model = make_model(
pool_op=op,
shape=(2, 28, 28, 12),
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_op_int8(op, input_0_scale, input_0_zero_point, input_1_scale, input_1_zero_point):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_CORSTONE300_RUNNER
dtype = "int8"
shape = [1, 16, 16, 3]
model = make_model(
op,
shape,
dtype,
dtype,
input_0_scale,
input_0_zero_point,
input_1_scale,
input_1_zero_point,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert any(attrs), "At least one function with external attributes was expected."
compilers = [
key == "Compiler" and value == "cmsis-nn" for attr in attrs for key, value in attr.items()
]
assert any(compilers), "Module does not contain function for cmsisnn target."
assert count_num_calls(orig_mod) == count_num_calls(
cmsisnn_mod
), "Number of calls changed during partitioning"
# validate the output
in_min, in_max = get_range_for_dtype_str(dtype)
inputs = {
"input_0": np.random.randint(in_min, high=in_max, size=shape, dtype=dtype),
"input_1": np.random.randint(in_min, high=in_max, size=shape, dtype=dtype),
}
output_list = generate_ref_data(orig_mod["main"], inputs)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_invalid_parameters(
in_dtype,
kernel_dtype,
kernel_zero_point,
padding,
):
ifm_shape = (1, 28, 28, 12)
out_channels = 2
input_scale = 1
input_zero_point = 24
kernel_scale = [0.11, 0.0237]
in_min, in_max = get_range_for_dtype_str(in_dtype)
kernel_layout = "HWIO"
kernel_shape = [3, 3, ifm_shape[3], out_channels]
output_scale, output_zero_point = get_conv2d_qnn_params(
kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
in_dtype,
kernel_dtype,
in_dtype,
False,
)
model, params = make_model(
shape=ifm_shape,
kernel_shape=kernel_shape,
input_zero_point=input_zero_point,
input_scale=input_scale,
kernel_zero_point=kernel_zero_point,
kernel_scale=kernel_scale,
output_zero_point=output_zero_point,
output_scale=output_scale,
padding=padding,
strides=(1, 1),
dilation=(1, 1),
groups=1,
dtype=in_dtype,
kernel_dtype=kernel_dtype,
out_channels=out_channels,
weight_format=kernel_layout,
enable_bias=True,
relu_type="NONE",
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert not any(attrs), "No function should have an external attribute."
def test_op_int8(
in_shape,
pool_size,
strides,
padding,
relu_type,
pool_type,
zero_point,
scale,
):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_USMP_CORSTONE300_RUNNER
dtype = "int8"
model = make_model(
pool_type,
in_shape,
pool_size,
strides,
padding,
dtype,
scale,
zero_point,
relu_type,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
in_min, in_max = get_range_for_dtype_str(dtype)
np.random.seed(0)
inputs = {
"input":
np.random.randint(in_min, high=in_max, size=in_shape, dtype="int8"),
}
output_list = generate_ref_data(orig_mod["main"], inputs)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=None,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_constant_input_int8(op, input_0, input_1):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_USMP_CORSTONE300_RUNNER
dtype = "int8"
shape = [1, 16, 16, 3]
input_0_scale = 0.256
input_0_zero_point = 33
input_1_scale = 0.128
input_1_zero_point = -24
model = make_model(
op,
input_0,
input_1,
input_0_scale,
input_0_zero_point,
input_1_scale,
input_1_zero_point,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
in_min, in_max = get_range_for_dtype_str(dtype)
inputs = {}
if isinstance(input_0, tvm.relay.expr.Var):
inputs.update({
"input_0":
np.random.randint(in_min, high=in_max, size=shape, dtype=dtype)
})
if isinstance(input_1, tvm.relay.expr.Var):
inputs.update({
"input_1":
np.random.randint(in_min, high=in_max, size=shape, dtype=dtype)
})
output_list = generate_ref_data(orig_mod["main"], inputs)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def get_time_frequency_transform(config):
"""
Returns a nn.Sequential block to do a time-frequency transform, and crop to the desired size.
The spectrogram has shape: [batch, channels, freq_bins, frames]
:param config:
:return:
"""
if config.use_mels:
transformer = nn.Sequential(
tforms_torch.MelSpectrogram(sample_rate=config.new_fs,
n_fft=config.n_fft,
win_length=config.win_length,
hop_length=config.hop_length,
f_min=float(config.fmin),
f_max=float(config.fmax),
pad=0,
n_mels=config.n_mels),
utils.make_module(tforms_mine.RandomCrop)(
config.max_length_frames),
tforms_torch.AmplitudeToDB(stype='power', top_db=80),
tforms_mine.ReScaleSpec([-1, 1]),
)
else:
transformer = nn.Sequential(
tforms_torch.Spectrogram(n_fft=config.n_fft,
win_length=config.win_length,
hop_length=config.hop_length,
pad=0,
power=2,
normalized=True),
tforms_mine.AmplitudeToDB(stype='power', top_db=80),
utils.make_module(tforms_mine.RandomCrop)(
config.max_length_frames),
tforms_mine.ReScaleSpec([-1, 1]),
)
return transformer
def test_invalid_softmax(in_dtype, out_dtype, zero_point, scale, out_zero_point, out_scale):
model = make_model(
[1, 16, 16, 3], in_dtype, out_dtype, zero_point, scale, out_zero_point, out_scale
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert not any(attrs), "No function should have an external attribute."
def test_op_int8(op, relu_type, input_0_scale, input_0_zero_point,
input_1_scale, input_1_zero_point):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_USMP_CORSTONE300_RUNNER
dtype = "int8"
shape = [1, 16, 16, 3]
model = make_model(
op,
generate_variable("input_0"),
generate_variable("input_1"),
input_0_scale,
input_0_zero_point,
input_1_scale,
input_1_zero_point,
relu_type,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
in_min, in_max = get_range_for_dtype_str(dtype)
inputs = {
"input_0": np.random.randint(in_min,
high=in_max,
size=shape,
dtype=dtype),
"input_1": np.random.randint(in_min,
high=in_max,
size=shape,
dtype=dtype),
}
output_list = generate_ref_data(orig_mod["main"], inputs)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_invalid_parameters(
in_dtype,
kernel_dtype,
kernel_zero_point,
):
ifm_shape = (1, 28, 28, 12)
out_channels = 2
input_scale = 1
input_zero_point = 24
kernel_scale = [0.11, 0.0237]
in_min, in_max = get_range_for_dtype_str(in_dtype)
kernel_layout = "HWIO"
kernel_shape = [3, 3, ifm_shape[3], out_channels]
output_scale, output_zero_point = get_conv2d_qnn_params(
kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
in_dtype,
kernel_dtype,
in_dtype,
False,
)
model, params = make_model(
shape=ifm_shape,
kernel_shape=kernel_shape,
input_zero_point=input_zero_point,
input_scale=input_scale,
kernel_zero_point=kernel_zero_point,
kernel_scale=kernel_scale,
output_zero_point=output_zero_point,
output_scale=output_scale,
padding="SAME",
strides=(1, 1),
dilation=(1, 1),
groups=1,
dtype=in_dtype,
kernel_dtype=kernel_dtype,
out_channels=out_channels,
weight_format=kernel_layout,
enable_bias=True,
relu_type="NONE",
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
assert_no_external_function(cmsisnn_mod)
def test_invalid_parameters(
in_dtype,
kernel_dtype,
kernel_zero_point,
):
in_shape = (2, 28)
out_channels = 2
input_scale = 1
input_zero_point = 24
kernel_scale = [0.11, 0.0237]
in_min, in_max = get_range_for_dtype_str(in_dtype)
kernel_shape = [out_channels, in_shape[1]]
conv2d_kernel_shape = [1, 1, kernel_shape[0], kernel_shape[1]]
output_scale, output_zero_point = get_conv2d_qnn_params(
conv2d_kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
in_dtype,
kernel_dtype,
in_dtype,
)
model, params = make_model(
in_shape=in_shape,
kernel_shape=kernel_shape,
input_zero_point=input_zero_point,
kernel_zero_point=kernel_zero_point,
input_scale=input_scale,
kernel_scale=kernel_scale,
output_zero_point=output_zero_point,
output_scale=output_scale,
dtype=in_dtype,
kernel_dtype=kernel_dtype,
out_channels=out_channels,
enable_bias=True,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert not any(attrs), "No function should have an external attribute."
def test_invalid_parameters():
model = make_model(
pool_op=relay.nn.avg_pool2d,
shape=(1, 28, 28, 12),
pool_size=(1, 1),
strides=(1, 1),
padding="VALID",
dtype="uint8",
scale=1,
zero_point=-33,
relu_type="RELU",
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_both_scalar_inputs_int8(op, ):
input_scale = 0.256
input_zero_point = 33
dtype = "int8"
model = make_model(
op,
generate_scalar_constant(),
generate_scalar_constant(),
input_scale,
input_zero_point,
input_scale,
input_zero_point,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_invalid_parameters(
in_dtype,
kernel_dtype,
kernel_zero_point,
):
in_shape = (2, 28)
out_channels = 2
input_scale = 1
input_zero_point = 24
kernel_scale = [0.11, 0.0237]
in_min, in_max = get_range_for_dtype_str(in_dtype)
kernel_shape = [out_channels, in_shape[1]]
conv2d_kernel_shape = [1, 1, kernel_shape[0], kernel_shape[1]]
output_scale, output_zero_point = get_conv2d_qnn_params(
conv2d_kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
in_dtype,
kernel_dtype,
in_dtype,
)
model, params = make_model(
in_shape=in_shape,
kernel_shape=kernel_shape,
input_zero_point=input_zero_point,
kernel_zero_point=kernel_zero_point,
input_scale=input_scale,
kernel_scale=kernel_scale,
output_zero_point=output_zero_point,
output_scale=output_scale,
dtype=in_dtype,
kernel_dtype=kernel_dtype,
out_channels=out_channels,
enable_bias=True,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
assert_no_external_function(cmsisnn_mod)
def test_invalid_parameters(
op,
input_dtype,
):
input_scale = 0.256
input_zero_point = 33
model = make_model(
op,
generate_variable("input_0", input_dtype),
generate_variable("input_1", input_dtype),
input_scale,
input_zero_point,
input_scale,
input_zero_point,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_invalid_parameters():
model = make_model(
pool_op=relay.nn.avg_pool2d,
shape=(1, 28, 28, 12),
pool_size=(1, 1),
strides=(1, 1),
padding="VALID",
dtype="uint8",
scale=1,
zero_point=-33,
relu_type="RELU",
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert not any(attrs), "No function should have an external attribute."
def test_depthwise_int8(
ifm_shape,
kernel_size,
padding,
strides,
dilation,
enable_bias,
relu_type,
input_zero_point,
input_scale,
kernel_scale,
out_channels,
depth_multiplier,
):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_CORSTONE300_RUNNER
dtype = "int8"
groups = 1
weight_format = "HWIO"
kernel_h = kernel_size[0]
kernel_w = kernel_size[1]
kernel_shape = (kernel_h, kernel_w, ifm_shape[3] // groups, out_channels)
kernel_zero_point = 0
in_min, in_max = get_range_for_dtype_str(dtype)
groups = ifm_shape[3]
weight_format = "HWOI"
kernel_shape = (kernel_h, kernel_w, ifm_shape[3], depth_multiplier)
out_channels = ifm_shape[3] * depth_multiplier
ks_len = len(kernel_scale)
kernel_scale = [kernel_scale[i % ks_len] for i in range(out_channels)]
output_scale, output_zero_point = get_conv2d_qnn_params(
kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
dtype,
dtype,
dtype,
True,
)
model, params = make_model(
ifm_shape,
kernel_shape,
input_zero_point,
input_scale,
kernel_zero_point,
kernel_scale,
output_zero_point,
output_scale,
padding,
strides,
dilation,
groups,
dtype,
dtype,
out_channels,
weight_format,
enable_bias,
relu_type,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert any(attrs), "At least one function with external attributes was expected."
compilers = [
key == "Compiler" and value == "cmsis-nn" for attr in attrs for key, value in attr.items()
]
assert any(compilers), "Module does not contain function for cmsis-nn target."
assert count_num_calls(orig_mod) == count_num_calls(
cmsisnn_mod
), "Number of calls changed during partitioning"
# validate the output
rng = np.random.default_rng(12345)
inputs = {"input": rng.integers(in_min, high=in_max, size=ifm_shape, dtype=dtype)}
output_list = generate_ref_data(orig_mod["main"], inputs, params)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=params,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_depthwise_int8(
ifm_shape,
kernel_size,
padding,
strides,
dilation,
enable_bias,
relu_type,
input_zero_point,
input_scale,
kernel_scale,
out_channels,
depth_multiplier,
):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_CORSTONE300_RUNNER
dtype = "int8"
groups = 1
weight_format = "HWIO"
kernel_h = kernel_size[0]
kernel_w = kernel_size[1]
kernel_shape = (kernel_h, kernel_w, ifm_shape[3] // groups, out_channels)
kernel_zero_point = 0
in_min, in_max = get_range_for_dtype_str(dtype)
groups = ifm_shape[3]
weight_format = "HWOI"
kernel_shape = (kernel_h, kernel_w, ifm_shape[3], depth_multiplier)
out_channels = ifm_shape[3] * depth_multiplier
ks_len = len(kernel_scale)
kernel_scale = [kernel_scale[i % ks_len] for i in range(out_channels)]
output_scale, output_zero_point = get_conv2d_qnn_params(
kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
dtype,
dtype,
dtype,
True,
)
model, params = make_model(
ifm_shape,
kernel_shape,
input_zero_point,
input_scale,
kernel_zero_point,
kernel_scale,
output_zero_point,
output_scale,
padding,
strides,
dilation,
groups,
dtype,
dtype,
out_channels,
weight_format,
enable_bias,
relu_type,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
rng = np.random.default_rng(12345)
inputs = {"input": rng.integers(in_min, high=in_max, size=ifm_shape, dtype=dtype)}
output_list = generate_ref_data(orig_mod["main"], inputs, params)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=params,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_op_int8(
enable_bias,
input_zero_point,
input_scale,
kernel_scale,
out_channels,
):
ifm_shape = (1, 28, 28, 3)
padding = "VALID"
strides = (1, 1)
dilation = (1, 1)
kernel_size = (3, 3)
kernel_zero_point = 0
groups = 1
weight_format = "HWIO"
kernel_h = kernel_size[0]
kernel_w = kernel_size[1]
dtype = "int8"
relu_type = "RELU"
in_min, in_max = get_range_for_dtype_str(dtype)
weight_shape = (kernel_h, kernel_w, ifm_shape[3] // groups, out_channels)
output_scale, output_zero_point = get_conv2d_qnn_params(
weight_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
dtype,
dtype,
dtype,
False,
)
model, params = make_model(
ifm_shape,
weight_shape,
input_zero_point,
input_scale,
kernel_zero_point,
kernel_scale,
output_zero_point,
output_scale,
padding,
strides,
dilation,
groups,
dtype,
dtype,
out_channels,
weight_format,
enable_bias,
relu_type,
)
mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(mod, params)
multiplier_array = []
shift_array = []
for i in range(out_channels):
multiplier, shift = quantize_scale(input_scale * kernel_scale[i] /
output_scale)
multiplier_array.append(multiplier)
shift_array.append(shift)
CheckGeneratedConstants(enable_bias, multiplier_array,
shift_array).visit_function(cmsisnn_mod["main"])
def test_invalid_datatype(op):
model = make_model(pool_op=op, dtype="int64")
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_op_int8(
in_shape,
enable_bias,
input_zero_point,
input_scale,
kernel_scale,
out_channels,
relu_type,
):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_USMP_CORSTONE300_RUNNER
dtype = "int8"
kernel_zero_point = 0
kernel_shape = [out_channels, in_shape[1]]
conv2d_kernel_shape = (1, 1, kernel_shape[0], kernel_shape[1])
in_min, in_max = get_range_for_dtype_str(dtype)
output_scale, output_zero_point = get_conv2d_qnn_params(
conv2d_kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
dtype,
)
model, params = make_model(
in_shape,
kernel_shape,
input_zero_point,
kernel_zero_point,
input_scale,
kernel_scale,
output_zero_point,
output_scale,
dtype,
dtype,
out_channels,
enable_bias,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
assert_partitioned_function(orig_mod, cmsisnn_mod)
# validate the output
rng = np.random.default_rng(12345)
inputs = {
"input": rng.integers(in_min, high=in_max, size=in_shape, dtype=dtype)
}
output_list = generate_ref_data(orig_mod["main"], inputs, params)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=params,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
def test_invalid_layout(op):
model = make_model(pool_op=op, layout="NCHW")
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod)
assert_no_external_function(cmsisnn_mod)
def test_op_int8(
in_shape,
enable_bias,
input_zero_point,
input_scale,
kernel_scale,
out_channels,
relu_type,
):
interface_api = "c"
use_unpacked_api = True
test_runner = AOT_CORSTONE300_RUNNER
dtype = "int8"
kernel_zero_point = 0
kernel_shape = [out_channels, in_shape[1]]
conv2d_kernel_shape = (1, 1, kernel_shape[0], kernel_shape[1])
in_min, in_max = get_range_for_dtype_str(dtype)
output_scale, output_zero_point = get_conv2d_qnn_params(
conv2d_kernel_shape,
input_scale,
input_zero_point,
kernel_scale,
kernel_zero_point,
dtype,
)
model, params = make_model(
in_shape,
kernel_shape,
input_zero_point,
kernel_zero_point,
input_scale,
kernel_scale,
output_zero_point,
output_scale,
dtype,
dtype,
out_channels,
enable_bias,
)
orig_mod = make_module(model)
cmsisnn_mod = cmsisnn.partition_for_cmsisnn(orig_mod, params)
# validate pattern matching
attrs = [
cmsisnn_mod[var.name_hint].attrs
for var in cmsisnn_mod.get_global_vars()
if cmsisnn_mod[var.name_hint].attrs
]
assert any(
attrs), "At least one function with external attributes was expected."
compilers = [
key == "Compiler" and value == "cmsis-nn" for attr in attrs
for key, value in attr.items()
]
assert any(
compilers), "Module does not contain function for cmsisnn target."
assert count_num_calls(orig_mod) == count_num_calls(
cmsisnn_mod), "Number of calls changed during partitioning"
# validate the output
rng = np.random.default_rng(12345)
inputs = {
"input": rng.integers(in_min, high=in_max, size=in_shape, dtype=dtype)
}
output_list = generate_ref_data(orig_mod["main"], inputs, params)
compile_and_run(
AOTTestModel(
module=cmsisnn_mod,
inputs=inputs,
outputs=output_list,
params=params,
output_tolerance=1,
),
test_runner,
interface_api,
use_unpacked_api,
)
