torch version 2.8

Author: airMeng

test/dtypes/test_affine_quantized.py

@@ -37,7 +37,7 @@
 from torchao.utils import (
     TORCH_VERSION_AT_LEAST_2_5,
     TORCH_VERSION_AT_LEAST_2_6,
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     is_fbcode,
     is_ROCM,
     is_sm_at_least_89,
@@ -62,7 +62,7 @@ def get_quantization_functions(
             base_functions.append(
                 int4_weight_only(group_size=32, layout=Int4CPULayout())
             )
-        elif device == "xpu" and TORCH_VERSION_AT_LEAST_2_7:
+        elif device == "xpu" and TORCH_VERSION_AT_LEAST_2_8:
             base_functions.append(
                 int4_weight_only(group_size=32, layout=Int4XPULayout())
             )

test/integration/test_integration.py

@@ -83,6 +83,7 @@
     TORCH_VERSION_AT_LEAST_2_5,
     TORCH_VERSION_AT_LEAST_2_6,
     TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     benchmark_model,
     is_fbcode,
     is_sm_at_least_90,
@@ -159,7 +160,7 @@ def _int4wo_api(mod, use_hqq=False):
         unwrap_tensor_subclass(mod)
     elif (
         is_device(next(mod.parameters()).device.type, "xpu")
-        and TORCH_VERSION_AT_LEAST_2_7
+        and TORCH_VERSION_AT_LEAST_2_8
     ):
         quantize_(
             mod, int4_weight_only(layout=Int4XPULayout()), set_inductor_config=False
@@ -1139,7 +1140,7 @@ def test_int4_weight_only_quant_subclass_api_grouped(self, device, dtype):
         layout_list = []
         if device == "cpu" and TORCH_VERSION_AT_LEAST_2_6:
             layout_list.append(Int4CPULayout())
-        elif device == "xpu" and TORCH_VERSION_AT_LEAST_2_7:
+        elif device == "xpu" and TORCH_VERSION_AT_LEAST_2_8:
             layout_list.append(Int4XPULayout())
         else:
             for inner_k_tiles in [4, 2]:

test/quantization/test_quant_api.py

@@ -58,7 +58,7 @@
     TORCH_VERSION_AT_LEAST_2_4,
     TORCH_VERSION_AT_LEAST_2_5,
     TORCH_VERSION_AT_LEAST_2_6,
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     is_sm_at_least_89,
     is_sm_at_least_90,
     unwrap_tensor_subclass,
@@ -239,7 +239,7 @@ def test_dynamic_quant_gpu_unified_api_eager_mode_impl(self):
         torch.testing.assert_close(quantized, compiled, atol=0, rtol=0)
 
     @unittest.skipIf(not torch.xpu.is_available(), "Need XPU available")
-    @unittest.skipIf(not TORCH_VERSION_AT_LEAST_2_7, "only works for torch 2.7+")
+    @unittest.skipIf(not TORCH_VERSION_AT_LEAST_2_8, "only works for torch 2.8+")
     def test_int4_wo_quant_save_load(self):
         m = ToyLinearModel().eval().cpu()
 

test/quantization/test_quant_primitives.py

@@ -38,7 +38,7 @@
     TORCH_VERSION_AT_LEAST_2_4,
     TORCH_VERSION_AT_LEAST_2_5,
     TORCH_VERSION_AT_LEAST_2_6,
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     is_fbcode,
 )
 
@@ -137,7 +137,7 @@ def _groupwise_affine_quantize_tensor_from_qparams(
 
     if TORCH_VERSION_AT_LEAST_2_5:
         if (not (is_device(w.device.type, "cpu") and TORCH_VERSION_AT_LEAST_2_6)) and (
-            not (is_device(w.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_7)
+            not (is_device(w.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_8)
         ):
             w_int4x8 = (w_int4x8[::, ::2] << 4 | w_int4x8[::, 1::2]).to(torch.uint8)
 
@@ -755,7 +755,7 @@ def test_groupwise_affine_dequantize_tensor_from_qparams(self):
                 ) and (
                     not (
                         is_device(input.device.type, "xpu")
-                        and TORCH_VERSION_AT_LEAST_2_7
+                        and TORCH_VERSION_AT_LEAST_2_8
                     )
                 ):
                     input_tmp = (input[::, ::2] << 4 | input[::, 1::2]).to(torch.uint8)

torchao/dtypes/uintx/int4_xpu_layout.py

@@ -14,7 +14,7 @@
 from torchao.dtypes.utils import AQTTensorImpl, Layout, is_device
 from torchao.quantization.quant_primitives import ZeroPointDomain
 from torchao.utils import (
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     fill_defaults,
 )
 
@@ -248,7 +248,7 @@ def from_plain(
 
         from torchao.quantization.utils import convert_weight_to_int4pack_xpu
 
-        if TORCH_VERSION_AT_LEAST_2_7:
+        if TORCH_VERSION_AT_LEAST_2_8:
             assert (
                 int_data.dtype == torch.int32
             ), "torch.ops.aten._convert_weight_to_int4pack_for_cpu expects `int32` dtype"

torchao/quantization/subclass.py

@@ -18,7 +18,7 @@
 )
 from torchao.utils import (
     TORCH_VERSION_AT_LEAST_2_6,
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
     find_multiple,
 )
 
@@ -480,7 +480,7 @@ def _quantized_op(act_mat, w_qtensor, bias):
                 w_qtensor.groupsize,
                 w_qtensor.scales_and_zeros,
             )
-        elif is_device(act_mat.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_7:
+        elif is_device(act_mat.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_8:
             if not w_qtensor.zero_point_domain == ZeroPointDomain.INT:
                 y = aten._weight_int4pack_mm(
                     act_mat.contiguous(),
@@ -698,7 +698,7 @@ def to_qtensor_components(
             int_data = aten._convert_weight_to_int4pack_for_cpu(
                 input_int4x8, inner_k_tiles
             )
-        if is_device(input_float.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_7:
+        if is_device(input_float.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_8:
             from torchao.quantization.utils import convert_weight_to_int4pack_xpu
 
             int_data = convert_weight_to_int4pack_xpu(

torchao/quantization/utils.py

@@ -23,7 +23,7 @@
 from torchao.utils import (
     TORCH_VERSION_AT_LEAST_2_5,
     TORCH_VERSION_AT_LEAST_2_6,
-    TORCH_VERSION_AT_LEAST_2_7,
+    TORCH_VERSION_AT_LEAST_2_8,
 )
 
 __all__ = [
@@ -434,7 +434,7 @@ def groupwise_affine_quantize_tensor_from_qparams(
         if (
             not (is_device(int_data.device.type, "cpu") and TORCH_VERSION_AT_LEAST_2_6)
         ) and (
-            not (is_device(int_data.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_7)
+            not (is_device(int_data.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_8)
         ):
             int_data = (int_data[::, ::2] << 4 | int_data[::, 1::2]).to(torch.uint8)
     return int_data
@@ -455,7 +455,7 @@ def groupwise_affine_dequantize_tensor_from_qparams(
         TORCH_VERSION_AT_LEAST_2_5
         and (w_int4x8.dtype == torch.uint8 or w_int4x8.shape[-1] > 1)
         and not (is_device(w_int4x8.device.type, "cpu") and TORCH_VERSION_AT_LEAST_2_6)
-        and not (is_device(w_int4x8.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_7)
+        and not (is_device(w_int4x8.device.type, "xpu") and TORCH_VERSION_AT_LEAST_2_8)
     ):
         data = w_int4x8.to(torch.int32)
         high_bits = data >> 4