def test_builder_to_backend_no_offset(self, compute_unit, backend):
        """
        Test per-channel de-quantization on sparse tensor without offset.

        data_mask = [[1, 1, 0, 0], [1, 1, 1, 0], [0, 0, 1, 1], [1, 1, 0, 0]]
        nonzero_data = [10, 11, 3, 4, 5, 6, 7, 8, 9]
        scale = [[0.1, 0.2, 0.3, 0.4]]
        The sparse tensor in the dense layout would look like:
         10   11
          3    4    5
                    6    7
          8    9

        The input `nonzero_data` would be dequantized per-column as in the dense layout, and the
        output sparse tensor in the dense layout would be:
         (10)*0.1   (11)*0.2
          (3)*0.1    (4)*0.2    (5)*0.3
                                (6)*0.3    (7)*0.4
          (8)*0.1    (9)*0.2

        The first output would be the same as the `data_mask`,
        The second output would be [1.0, 1.1, 0.3, 0.8, 1.5, 1.8, 2.8, 0.8, 1.8]
        """
        data_dtype = types.int8
        x_val = np.ones(9).astype(np.float32)
        input_placeholders = {"x": mb.placeholder(shape=x_val.shape)}
        np_dtype = types.nptype_from_builtin(data_dtype)

        def build(x):
            data_mask_val = np.array(
                [[1, 1, 0, 0], [1, 1, 1, 0], [0, 0, 1, 1], [1, 1, 0, 0]]
            ).astype(types.np_uint1_dtype)
            nonzero_data_val = np.array([10, 11, 3, 4, 5, 6, 7, 8, 9]).astype(np_dtype)
            scale_val = np.array([[0.1, 0.2, 0.3, 0.4]])

            output_mask, output_nonzero_data = mb.constexpr_sparse_blockwise_shift_scale(
                data_mask=data_mask_val,
                nonzero_data=nonzero_data_val,
                scale=scale_val,
            )
            return mb.add(x=x, y=output_nonzero_data)

        expected_output = np.array([1.0, 2.2, 0.3, 0.8, 1.5, 1.8, 2.8, 0.8, 1.8]) + 1
        run_compare_builder(
            build,
            input_placeholders,
            input_values={"x": x_val},
            expected_output_types=expected_output.shape + (types.fp32,),
            expected_outputs=expected_output,
            compute_unit=compute_unit,
            backend=backend,
        )

        Test per-channel de-quantization on sparse tensor without offset.

        data_mask = [[1, 1, 0, 0], [1, 1, 1, 0], [0, 0, 1, 1], [1, 1, 0, 0]]
        nonzero_data = [10, 11, 3, 4, 5, 6, 7, 8, 9]
        scale = [[0.1, 0.2, 0.3, 0.4]]
        The sparse tensor in the dense layout would look like:
         10   11
          3    4    5
                    6    7
          8    9

        The input `nonzero_data` would be dequantized per-column as in the dense layout, and the
        output sparse tensor in the dense layout would be:
         (10)*0.1   (11)*0.2
          (3)*0.1    (4)*0.2    (5)*0.3
                                (6)*0.3    (7)*0.4
          (8)*0.1    (9)*0.2

        The first output would be the same as the `data_mask`,
        The second output would be [1.0, 1.1, 0.3, 0.8, 1.5, 1.8, 2.8, 0.8, 1.8]
        
coremltools/converters/mil/mil/ops/tests/iOS18/test_compression.py