Add fp16 qb4w linear test coverage (#3626)

Summary:
Pull Request resolved: #3626

Add test coverage in ExecuTorch op-level linear test coverage for 4-bit blockwise weights / fp16.

Reviewed By: digantdesai

Differential Revision: D57335871

fbshipit-source-id: 4813941c1ac63e21fcb5b5c4f563720b7c74ba79

Author: GregoryComer

backends/xnnpack/test/ops/linear.py

@@ -412,9 +412,10 @@ def __init__(
                 )
                 self.quant_weight_per_channel()
 
-            # TODO - change bias dtyoe to arg.dtype
             self.bias = (
-                torch.nn.Parameter(torch.randn(self.oc), requires_grad=False)
+                torch.nn.Parameter(
+                    torch.randn(self.oc).to(self.op_dtype), requires_grad=False
+                )
                 if use_bias
                 else None
             )
@@ -595,14 +596,14 @@ def fwd_weight_per_channel_group(self) -> torch.Tensor:
 
         def forward(self, input: torch.Tensor) -> torch.Tensor:
             # Input
-            input = self.fwd_input_per_token(input)
+            input = self.fwd_input_per_token(input).to(self.op_dtype)
 
             # Weights
             w = (
                 self.fwd_weight_per_channel_group()
                 if self.w_scales.ndim == 2
                 else self.fwd_weight_per_channel()
-            )
+            ).to(self.op_dtype)
             assert isinstance(w, torch.Tensor)
             return torch.nn.functional.linear(input, w, self.bias)
 
@@ -734,6 +735,38 @@ def test_qd8_fp32_per_token_weight_per_channel_group_int4(self):
                     use_bias=use_bias,
                 )
 
+    def test_qd8_fp16_per_token_weight_per_channel_group_int4(self):
+        M_sizes = [1, 2, 17, 31]
+        K_sizes = [8, 32, 64, 128]
+        bl_sizes = [8, 16, 16, 32]
+        N_sizes = [2, 17, 92, 128]
+
+        for use_bias in [True, False]:
+            for i, _ in enumerate(M_sizes):
+                M = int(M_sizes[i])
+                K = int(K_sizes[i])
+                N = int(N_sizes[i])
+                bl = int(bl_sizes[i])
+                mod = self.ManualDQLinear(
+                    input_channels=K,
+                    output_channels=N,
+                    weight_n_bit=4,
+                    dtype=torch.float16,
+                    group_size=bl,
+                    force_groupwise_quant=True,
+                    use_bias=use_bias,
+                )
+
+                inputs = (torch.randn(1, M, K, dtype=torch.float16),)
+                self._test_manual_dq_linear(
+                    mod,
+                    inputs,
+                    weight_groupwise=True,
+                    use_bias=use_bias,
+                    atol=0.1,
+                    rtol=0.1,
+                )
+
     def _test_linear(
         self,
         make_module,