def METHOD_NAME(accel_type):
    dtype = "int8"
    ifm_shape = (1, 55, 55, 3)
    def create_tflite_graph():
        class Model(tf.Module):
            @tf.function
            def tf_func(self, x):
                weight_shape = (3, 3, ifm_shape[3], 4)
                weight = tf.constant(
                    np.random.uniform(low=0, high=0.3, size=weight_shape), dtype=tf.float32
                )
                # The input strides to the TensorFlow API needs to be of shape 1x4
                op = tf.nn.conv2d(x, weight, strides=(1, 2, 2, 1), padding="SAME", dilations=(1, 1))
                op = tf.nn.tanh(op)
                op = tf.nn.tanh(op)
                weight_shape2 = (2, 3, 4, 1)
                weight2 = tf.constant(
                    np.random.uniform(low=0, high=0.3, size=weight_shape2), dtype=tf.float32
                )
                op = tf.nn.depthwise_conv2d(
                    op, weight2, strides=(1, 1, 1, 1), padding="VALID", dilations=(2, 2)
                )
                op = tf.nn.sigmoid(op)
                op = tf.nn.max_pool(op, (1, 1), strides=(1, 1, 1, 1), padding="SAME")
                op = tf.nn.tanh(op)
                return op
        model = Model()
        concrete_func = model.tf_func.get_concrete_function(
            tf.TensorSpec(ifm_shape, dtype=tf.float32)
        )
        # Convert the model
        def representative_dataset():
            for _ in range(100):
                data = 0.7 * 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 = create_tflite_graph()
    tflite_model = tflite.Model.Model.GetRootAsModel(tflite_graph, 0)
    relay_module, params = relay.frontend.from_tflite(
        tflite_model,
        shape_dict={"input": ifm_shape},
        dtype_dict={"input": dtype},
    )
    mod = partition_for_ethosu(relay_module, params)
    # Generate reference data
    input_data, output_data = infra.generate_ref_data_tflite(tflite_graph)
    test_runner = infra.create_test_runner(accel_type)
    compiled_models = infra.build_source(
        mod,
        input_data,
        output_data,
        test_runner,
    )
    # Assumes only two runtime.Modules are created -- i.e. single offload module
    ethosu_module = compiled_models[0].executor_factory.lib.imported_modules[0].imported_modules[0]
    # Verify generated C source
    get_artifacts = tvm._ffi.get_global_func("runtime.module.ethos-u.get_artifacts")
    compilation_artifacts = get_artifacts(ethosu_module)
    cmms = bytes.fromhex(compilation_artifacts[0].command_stream)
    infra.print_payload(cmms)
    infra.verify_source(compiled_models, test_runner)