fbgemm-gpu-genai-nightly 2025.10.2__cp310-cp310-manylinux_2_28_x86_64.whl → 2025.10.5__cp310-cp310-manylinux_2_28_x86_64.whl

fbgemm_gpu/config/feature_list.py

@@ -11,7 +11,7 @@ from enum import auto, Enum
 import torch
 
 try:
-    torch.ops.load_library("//deeplearning/fbgemm/fbgemm_gpu:config_cpp")
+    torch.ops.load_library("//deeplearning/fbgemm/fbgemm_gpu:config_cpp_torch_op")
 except Exception:
     import fbgemm_gpu  # noqa F401
 

fbgemm_gpu/docs/version.py

@@ -6,6 +6,6 @@
 # This source code is licensed under the BSD-style license found in the
 # LICENSE file in the root directory of this source tree.
 
-__version__: str = "2025.10.2"
+__version__: str = "2025.10.5"
 __target__: str = "genai"
 __variant__: str = "cuda"

fbgemm_gpu/experimental/gemm/triton_gemm/fp4_quantize.py

@@ -5540,3 +5540,53 @@ def calculate_group_max(
         USE_INT64=use_int64,
     )
     return out, tensor_idx
+
+
+def get_nvfp4_global_scales_naive(
+    xs: list[torch.Tensor], ws: list[torch.Tensor]
+) -> tuple[list[torch.Tensor], list[torch.Tensor], list[torch.Tensor]]:
+    """
+    Get global scales for each tensor in xs and ws.
+    This is done "naively" (not efficiently with a kernel). This function is used in unit tests or debugging.
+    """
+    global_scales = []
+    x_global_scales = []
+    w_global_scales = []
+
+    for x, w in zip(xs, ws):
+        # pyre-ignore
+        x_global_scale: torch.Tensor = (448.0 * 6.0) / torch.amax(
+            torch.abs(x.flatten()), dim=-1
+        ).to(torch.float32)
+        # pyre-ignore
+        w_global_scale: torch.Tensor = (448.0 * 6.0) / torch.amax(
+            torch.abs(w.flatten()), dim=-1
+        ).to(torch.float32)
+        # pyre-ignore
+        global_scale: torch.Tensor = 1 / (x_global_scale * w_global_scale)
+
+        global_scales.append(global_scale)
+        x_global_scales.append(x_global_scale)
+        w_global_scales.append(w_global_scale)
+
+    return global_scales, x_global_scales, w_global_scales
+
+
+def quantize_nvfp4_naive(
+    xs: list[torch.Tensor], global_scales: list[torch.Tensor]
+) -> tuple[
+    list[torch.Tensor],
+    list[torch.Tensor],
+]:
+    """
+    Quantize A to NVFP4 format.
+    This is done "naively" using a kernel for each group. This function is largely used in unit tests or debugging.
+    """
+    xqs, x_scales = zip(
+        *(
+            triton_scale_nvfp4_quant(x, global_scale)
+            for x, global_scale in zip(xs, global_scales)
+        )
+    )
+
+    return xqs, x_scales

fbgemm_gpu/experimental/gen_ai/bench/quantize_ops.py

@@ -16,9 +16,11 @@ import triton  # @manual=//triton:triton
 from fbgemm_gpu.experimental.gemm.triton_gemm.fp4_quantize import (
     _to_blocked,
     calculate_group_max,
+    get_nvfp4_global_scales_naive,
     mega_fp4_pack,
     mega_fp4_quantize_kernel,
     mega_fp4_unpack,
+    quantize_nvfp4_naive,
     triton_quantize_mx4_unpack,
     triton_scale_nvfp4_quant,
     triton_scale_nvfp4_quant_rms,
@@ -96,6 +98,10 @@ except ImportError:
 quantize_op_registry = []
 
 
+def round_up(x: int, y: int) -> int:
+    return ((x + y - 1) // y) * y
+
+
 class QuantizeOpBase(metaclass=abc.ABCMeta):
     """Helper abstract class to define expected methods of quantize ops."""
 
@@ -2592,6 +2598,336 @@ class MXFP4StackedGroupedGemm(QuantizeOpBase):
         return True
 
 
+@register_quantize_op
+class MXFP4GroupedGemm2D3D(QuantizeOpBase):
+    """
+    MXFP4 grouped GEMM with blockwise scaling and Torch 2D2D API.
+    """
+
+    def preprocess(self, xs, ws):
+        m_sizes = [x.shape[0] for x in xs]
+        m_offsets = torch.cumsum(torch.tensor(m_sizes), dim=0).to(
+            dtype=torch.int32, device=xs[0].device
+        )
+
+        wqs = []
+        w_scales = []
+        for w in ws:
+            wq, w_scale = triton_quantize_mx4_unpack(w)
+            wqs.append(wq)
+            w_scales.append(w_scale)
+
+        wq = torch.stack(wqs, dim=0)
+        w_scale = torch.stack(w_scales, dim=0)
+
+        return xs, wq, w_scale, m_offsets
+
+    def quantize(self, xs, wq, w_scale, m_offsets):
+        xqs = []
+        x_scales = []
+        for x in xs:
+            xq, x_scale = triton_quantize_mx4_unpack(x)
+            xqs.append(xq)
+            x_scales.append(x_scale)
+
+        xq = torch.cat(xqs, dim=0)
+        x_scale = torch.stack(x_scales, dim=0)
+
+        xq = xq.view(torch.float4_e2m1fn_x2)
+        wq = wq.view(torch.float4_e2m1fn_x2)
+        x_scale = x_scale.view(torch.float8_e8m0fnu)
+        w_scale = w_scale.view(torch.float8_e8m0fnu)
+
+        return xq, wq, x_scale, w_scale, m_offsets
+
+    def compute(
+        self,
+        xq,
+        wq,
+        x_scale,
+        w_scale,
+        m_offsets,
+    ):
+        return torch.ops.fbgemm.f4f4bf16_grouped_mm(
+            xq,
+            wq.transpose(-2, -1),
+            x_scale,
+            w_scale,
+            m_offsets,
+        )
+
+    def quantize_and_compute(self, xs, wq, w_scale, m_offsets, output):
+        args = self.quantize(xs, wq, w_scale, m_offsets, output)
+        return self.compute(**args)
+
+    @property
+    def name(self) -> str:
+        return "cutlass_mx_f4f4bf16_grouped_mm_2d_3d"
+
+    @property
+    def cuda(self) -> bool:
+        return True
+
+    @property
+    def hip(self) -> bool:
+        return False
+
+
+@register_quantize_op
+class MXFP4GroupedGemm2D2D(QuantizeOpBase):
+    """
+    MXFP4 grouped GEMM with blockwise scaling and Torch 2D2D API.
+    """
+
+    def preprocess(self, xs, ws):
+        k_sizes = [x.shape[1] for x in xs]
+        k_offsets = torch.cumsum(torch.tensor(k_sizes), dim=0).to(
+            dtype=torch.int32, device=xs[0].device
+        )
+
+        wqs = []
+        w_scales = []
+        for w in ws:
+            wq, w_scale = triton_quantize_mx4_unpack(w)
+            wqs.append(wq)
+            w_scales.append(w_scale)
+
+        wq = torch.cat(wqs, dim=1)
+        w_scale = torch.stack(w_scales, dim=0)
+
+        return xs, wq, w_scale, k_offsets
+
+    def quantize(self, xs, wq, w_scale, k_offsets):
+        xqs = []
+        x_scales = []
+        for x in xs:
+            xq, x_scale = triton_quantize_mx4_unpack(x)
+            xqs.append(xq)
+            x_scales.append(x_scale)
+
+        xq = torch.cat(xqs, dim=1)
+        x_scale = torch.stack(x_scales, dim=0)
+
+        xq = xq.view(torch.float4_e2m1fn_x2)
+        wq = wq.view(torch.float4_e2m1fn_x2)
+        x_scale = x_scale.view(torch.float8_e8m0fnu)
+        w_scale = w_scale.view(torch.float8_e8m0fnu)
+
+        return xq, wq, x_scale, w_scale, k_offsets
+
+    def compute(
+        self,
+        xq,
+        wq,
+        x_scale,
+        w_scale,
+        k_offsets,
+    ):
+        return torch.ops.fbgemm.f4f4bf16_grouped_mm(
+            xq,
+            wq.transpose(-2, -1),
+            x_scale,
+            w_scale,
+            k_offsets,
+        )
+
+    def quantize_and_compute(self, xs, wq, w_scale, k_offsets, output):
+        args = self.quantize(xs, wq, w_scale, k_offsets, output)
+        return self.compute(**args)
+
+    @property
+    def name(self) -> str:
+        return "cutlass_mx_f4f4bf16_grouped_mm_2d_2d"
+
+    @property
+    def cuda(self) -> bool:
+        return True
+
+    @property
+    def hip(self) -> bool:
+        return False
+
+
+@register_quantize_op
+class NVFP4GroupedGemm2D3D(QuantizeOpBase):
+    """
+    NVFP4 grouped GEMM with blockwise scaling and Torch 2D3D API.
+    """
+
+    def preprocess(self, x, w):
+        m_values = [i.shape[0] for i in x]
+        m_sizes = torch.tensor(m_values).to(dtype=torch.int64, device=x[0].device)
+        x = torch.concat(x, dim=0).contiguous()
+
+        def get_global_scale(x, w, m_sizes):
+            G = len(w)
+            w_global_scale = []
+            global_scale = []
+
+            x_global_scale, tensor_idx = calculate_group_max(x, m_sizes=m_sizes)
+
+            for i in range(G):
+                w_global_scale_ = (448.0 * 6.0) / torch.amax(
+                    torch.abs(w[i].flatten()), dim=-1
+                ).to(torch.float32)
+
+                global_scale_ = 1 / (x_global_scale[i] * w_global_scale_)
+
+                w_global_scale.append(w_global_scale_)
+                global_scale.append(global_scale_)
+
+            return x_global_scale, w_global_scale, global_scale, tensor_idx
+
+        # Compute global scale for each group
+        G = m_sizes.numel()
+        x_global_scale, w_global_scale, global_scale, tensor_idx = get_global_scale(
+            x, w, m_sizes
+        )
+        global_scale = torch.stack(global_scale, dim=0).contiguous()
+
+        wq, w_scale = zip(
+            *[triton_scale_nvfp4_quant(w[i], w_global_scale[i]) for i in range(G)]
+        )
+        wq = torch.stack(wq, dim=0).contiguous()
+        w_scale = torch.stack(w_scale, dim=0).contiguous()
+
+        return x, wq, w_scale, x_global_scale, global_scale, m_sizes, tensor_idx
+
+    def quantize(
+        self, x, wq, w_scale, x_global_scale, global_scale, m_sizes, tensor_idx
+    ):
+        xq, x_scale, _ = mega_fp4_quantize_kernel(
+            m_sizes, x, x_global_scale, optional_tensor_idx=tensor_idx
+        )
+
+        x_scale = x_scale.reshape(-1, x.shape[1] // 16)
+        offsets = torch.cumsum(m_sizes, dim=0).to(torch.int32)
+
+        xq = xq.view(torch.float4_e2m1fn_x2)
+        wq = wq.view(torch.float4_e2m1fn_x2)
+        x_scale = x_scale.view(torch.float8_e4m3fn)
+        w_scale = w_scale.view(torch.float8_e4m3fn)
+
+        return (
+            xq,
+            wq.transpose(-2, -1),
+            x_scale,
+            w_scale,
+            offsets,
+            None,
+            global_scale,
+        )
+
+    def compute(
+        self,
+        xq,
+        wq,
+        x_scale,
+        w_scale,
+        offsets,
+        output,
+        global_scale,
+    ):
+        return torch.ops.fbgemm.f4f4bf16_grouped_mm(
+            xq,
+            wq,
+            x_scale,
+            w_scale,
+            offsets,
+            output,
+            global_scale,
+        )
+
+    def quantize_and_compute(self, xq, wq, x_scale, w_scale, global_scale, k_offsets):
+        args = self.quantize(xq, wq, x_scale, w_scale, global_scale, k_offsets)
+        return self.compute(**args)
+
+    @property
+    def name(self) -> str:
+        return "cutlass_nv_f4f4bf16_grouped_mm_2d_3d"
+
+    @property
+    def hip(self) -> bool:
+        return False
+
+    @property
+    def cuda(self) -> bool:
+        return True
+
+
+@register_quantize_op
+class NVFP4GroupedGemm2D2D(QuantizeOpBase):
+    """
+    NVFP4 grouped GEMM with blockwise scaling and Torch 2D2D API.
+    """
+
+    def preprocess(self, xs, ws):
+        k_sizes = [x.shape[1] for x in xs]
+        k_offsets = torch.cumsum(torch.tensor(k_sizes), dim=0).to(
+            dtype=torch.int32, device=xs[0].device
+        )
+
+        global_scales, x_global_scales, w_global_scales = get_nvfp4_global_scales_naive(
+            xs, ws
+        )
+        wqs, w_scales = quantize_nvfp4_naive(ws, w_global_scales)
+        wq = torch.cat(wqs, dim=1).view(torch.float4_e2m1fn_x2)
+        w_scale = (
+            torch.stack(w_scales, dim=0)
+            .reshape(round_up(wq.size(0), 128), -1)
+            .view(torch.float8_e4m3fn)
+        )
+        global_scale = torch.stack(global_scales, dim=0)
+
+        return xs, wq, w_scale, global_scale, x_global_scales, k_offsets
+
+    def quantize(self, xs, wq, w_scale, global_scale, x_global_scales, k_offsets):
+        xqs, x_scales = quantize_nvfp4_naive(xs, x_global_scales)
+        xq = torch.cat(xqs, dim=1).view(torch.float4_e2m1fn_x2)
+        x_scale = (
+            torch.stack(x_scales, dim=0)
+            .reshape(round_up(xq.size(0), 128), -1)
+            .view(torch.float8_e4m3fn)
+        )
+
+        return xq, wq, x_scale, w_scale, k_offsets, global_scale
+
+    def compute(
+        self,
+        xq,
+        wq,
+        x_scale,
+        w_scale,
+        k_offsets,
+        global_scale,
+    ):
+        return torch.ops.fbgemm.f4f4bf16_grouped_mm(
+            xq,
+            wq.transpose(-2, -1),
+            x_scale,
+            w_scale,
+            k_offsets,
+            None,
+            global_scale,
+        )
+
+    def quantize_and_compute(self, xq, wq, x_scale, w_scale, global_scale, k_offsets):
+        args = self.quantize(xq, wq, x_scale, w_scale, global_scale, k_offsets)
+        return self.compute(**args)
+
+    @property
+    def name(self) -> str:
+        return "cutlass_nv_f4f4bf16_grouped_mm_2d_2d"
+
+    @property
+    def hip(self) -> bool:
+        return False
+
+    @property
+    def cuda(self) -> bool:
+        return True
+
+
 @register_quantize_op
 class NVFP4StackedGroupedGemm(QuantizeOpBase):
     """
@@ -3064,9 +3400,6 @@ class MXFP8GroupedGemm2d2d(QuantizeOpBase):
         x_blocked_scale_list = []
         w_blocked_scale_list = []
 
-        def round_up(x: int, y: int) -> int:
-            return ((x + y - 1) // y) * y
-
         for group_idx in range(G):
             # to_mxfp8 per group
             prev_group_end_offset = (

{fbgemm_gpu_genai_nightly-2025.10.2.dist-info → fbgemm_gpu_genai_nightly-2025.10.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fbgemm_gpu_genai_nightly
-Version: 2025.10.2
+Version: 2025.10.5
 Home-page: https://github.com/pytorch/fbgemm
 Author: FBGEMM Team
 Author-email: packages@pytorch.org

{fbgemm_gpu_genai_nightly-2025.10.2.dist-info → fbgemm_gpu_genai_nightly-2025.10.5.dist-info}/RECORD

@@ -1,8 +1,8 @@
 fbgemm_gpu/__init__.py,sha256=FdQCmpvETH80tlIPP6W8MrOmzLaX9eoGY-fuHtVPbj0,5747
-fbgemm_gpu/asmjit.so,sha256=s2majpI_vsFgc4Vh8szCK4xFYXyT5A0K6HwepGBwrqQ,501728
+fbgemm_gpu/asmjit.so,sha256=5N9owjQJb6tzArT7Lzjl_gIEjn5eDTvOvjxwLEVTaV4,484232
 fbgemm_gpu/batched_unary_embeddings_ops.py,sha256=GYeJ9pg-Wc9FokXVci_npDsL6UV18-pJXID2xzrJ9O8,2904
 fbgemm_gpu/enums.py,sha256=37ewGSfO1x7sO31ZkRiqV1yKuklfHXT5qZIxzeeGogo,755
-fbgemm_gpu/fbgemm.so,sha256=P-80NThzhyQWN9WMb2kYfl04sAgPCehbdArfnktJaqw,5634424
+fbgemm_gpu/fbgemm.so,sha256=E4-lI4QpwkjkPmH3u1IKBUjBEDrdbL6YgeFnhIt5YKo,5811328
 fbgemm_gpu/metrics.py,sha256=TsurFLJf0nJvPDN7urWb4LMQlf5RgdWPTTTDO7S4wtI,5663
 fbgemm_gpu/permute_pooled_embedding_modules.py,sha256=vOXMYclaGnwSt0St_SOAlAe18kz6WjMyTeHnC9jLhcE,5130
 fbgemm_gpu/permute_pooled_embedding_modules_split.py,sha256=f3VJvH_kw9Ltd_DXtaf_PJPHmlmEWrQgzQ7MDkhh5Nw,2746
@@ -23,7 +23,7 @@ fbgemm_gpu/ssd_split_table_batched_embeddings_ops.py,sha256=7qGkO8FARku38mFYl4Bc
 fbgemm_gpu/tbe_input_multiplexer.py,sha256=TQjwkJ2JkOaQsMYuRdk9RbNa9759EPEtx8bYclChtZY,3063
 fbgemm_gpu/uvm.py,sha256=guNK8ZzR80jmv-CyRgEhxhVYhjz3R9d6tB8Hu1uWDUo,1047
 fbgemm_gpu/config/__init__.py,sha256=yN0KAneCICgF2BTfOYGsd0qU1PvZX_6msC6YHHZKLMg,292
-fbgemm_gpu/config/feature_list.py,sha256=P9lL-6e6sy0qrkMPMljhT1ibtU45f8hg5otFCNz96EA,2350
+fbgemm_gpu/config/feature_list.py,sha256=iDOGr9nwTqUhWsqOefRIqIo1jwLSeSII4jGnLeU01kg,2359
 fbgemm_gpu/docs/__init__.py,sha256=DR6hMSQrsZALfH2AnuJQ4Zq2CfBUUhMN8YjD6APjiAE,523
 fbgemm_gpu/docs/common.py,sha256=8ipXTwVb222X-aZ71O6n8fhxHCHPNhJEHMFiO7epcIs,273
 fbgemm_gpu/docs/examples.py,sha256=ZMN_6sL74LH_hrp2bF_hmg8gi29GhcgvwV3kCMjxkoE,2377
@@ -32,18 +32,18 @@ fbgemm_gpu/docs/merge_pooled_embedding_ops.py,sha256=oJLgSgZQmhsyGLbTmZTxNgQrk65
 fbgemm_gpu/docs/permute_pooled_embedding_ops.py,sha256=tZUqLVXlk5O6VAKKDA-OEMx2fCu5QPOOeoAPZA9_nLY,4454
 fbgemm_gpu/docs/quantize_ops.py,sha256=xTtOaVK1P02ymreE_i21YiyYDZCqhoZY9eWp_mEIRlo,1297
 fbgemm_gpu/docs/sparse_ops.py,sha256=gSLUFdnu8lle_6gLewFkM20wL3ek2jKLvDGMKR6POaY,27292
-fbgemm_gpu/docs/version.py,sha256=U9HFTyqt_827sXJZ7N9Dik7e18vj0x7B38Go9HoScG4,316
+fbgemm_gpu/docs/version.py,sha256=axMqnt_uxHLVuIT4M2QVOCEQgEYGPpnbD2G5jg9tAXA,316
 fbgemm_gpu/experimental/example/__init__.py,sha256=V_XrGMq2oNVMpzwe1srlaTaHeIcZJw5oAGbo3seM_Ks,870
-fbgemm_gpu/experimental/example/fbgemm_gpu_experimental_example_py.so,sha256=8RvrBvXgLDhUaB7cM9CuAA5btfIlgbpcX0C9q9eW0X0,243904
+fbgemm_gpu/experimental/example/fbgemm_gpu_experimental_example_py.so,sha256=vUe4mdTJLEcR2yxamKqjTN7K7vCWkTFlGcdcfxCU56c,232488
 fbgemm_gpu/experimental/example/utils.py,sha256=Je__VkMlBMLOhh7NXOocOdvaa2gz9kl9Dkqeu25tpFA,562
 fbgemm_gpu/experimental/gemm/triton_gemm/__init__.py,sha256=AqHefiOaN_SjP5ew7RYGuKFuSlhedOJL_6f97TtLv7c,566
-fbgemm_gpu/experimental/gemm/triton_gemm/fp4_quantize.py,sha256=I2xf2DlU27KA9s0256tkGLhdOoImUv7i7oHc8bz5Y2M,211841
+fbgemm_gpu/experimental/gemm/triton_gemm/fp4_quantize.py,sha256=qJmQOBa9iW-HhRYm8lzE36Lz7vpBevCS6pWQyy33pag,213404
 fbgemm_gpu/experimental/gemm/triton_gemm/fp8_gemm.py,sha256=5m4SdgUsf2rM_Vul8czgRn_5oVnyi-52TmeidXh05hg,152754
 fbgemm_gpu/experimental/gemm/triton_gemm/grouped_gemm.py,sha256=rbjxTMefjQWgJrWK_bYFtBklJigFwv4awPeVexkkiIA,44511
 fbgemm_gpu/experimental/gemm/triton_gemm/matmul_perf_model.py,sha256=SltbY_dsit5e7B8lDIB_VYPrEq0t9kckthj9mQaVNfA,7571
 fbgemm_gpu/experimental/gemm/triton_gemm/utils.py,sha256=rULXIpVaaRS3GKUZ1RHcWUrUyy0xMVREwS1SFShGgcw,4302
 fbgemm_gpu/experimental/gen_ai/__init__.py,sha256=qwfuF5E5K4oDiH7RJkpC7zth3kAsG7wv_glCl2A_G2A,1860
-fbgemm_gpu/experimental/gen_ai/fbgemm_gpu_experimental_gen_ai.so,sha256=vNA-N1bO4EkSWAsxDE8NQbW5ZrUs1JQvO4gd5ReFMf4,78714952
+fbgemm_gpu/experimental/gen_ai/fbgemm_gpu_experimental_gen_ai.so,sha256=i68jA82SlC56vMpmgv1uI196AaQzS4QHCh1V4P67_H8,77952696
 fbgemm_gpu/experimental/gen_ai/quantize.py,sha256=KAljWSdN-1_c5DWfT-3MDxWLMULK49Yu36t6TmQI9Tw,12599
 fbgemm_gpu/experimental/gen_ai/attention/cutlass_blackwell_fmha/__init__.py,sha256=oExepXpjMOwM43gARZARY0UtR-EX2zqRnSrOaQPy448,1044
 fbgemm_gpu/experimental/gen_ai/attention/cutlass_blackwell_fmha/cutlass_blackwell_fmha_custom_op.py,sha256=FADVTYzS2u8fA-3iChS5CbtWd0mWF8F3lnXcwr_7vDw,7821
@@ -52,7 +52,7 @@ fbgemm_gpu/experimental/gen_ai/bench/__init__.py,sha256=GvCUF6o7wCR3XSWingWKxn_Y
 fbgemm_gpu/experimental/gen_ai/bench/comm_bench.py,sha256=ApEyJOf_rdIo8V_EgvhZXBGNov8ITC_dnB95v8szulI,8515
 fbgemm_gpu/experimental/gen_ai/bench/gather_scatter_bench.py,sha256=K9Nib6D7xJbw1QwEVuCJrVyI1qs988moo3cieVKYuFY,12057
 fbgemm_gpu/experimental/gen_ai/bench/quantize_bench.py,sha256=BWl6t-4acbuRSEX2aVNDlFrSWZkqMWK2sI3VONaMd3Q,24047
-fbgemm_gpu/experimental/gen_ai/bench/quantize_ops.py,sha256=9LHqmEafRadDP4m0LHX1zd0PiAMIg83s_Q8ebgZnoMg,95796
+fbgemm_gpu/experimental/gen_ai/bench/quantize_ops.py,sha256=H6AchejyZs76_snM_ae5vV0cPr_Q0h35OQ8qED0r1N4,104915
 fbgemm_gpu/experimental/gen_ai/moe/README.md,sha256=z9ybHmv4KFJ1drj5OByuFaOY0tRQwwiIW3Q22TB_2-k,904
 fbgemm_gpu/experimental/gen_ai/moe/__init__.py,sha256=XzFeGAmhJ-QvsUyzmlRZWExvaVJ1CbBk3ENo-LK3KHk,2052
 fbgemm_gpu/experimental/gen_ai/moe/activation.py,sha256=NiXhWyCNagI3P9N3N89iSX7xKuShdkq9DxEUAzoV6y0,7892
@@ -121,7 +121,7 @@ fbgemm_gpu/utils/loader.py,sha256=1hCEhNvkflniH46fGcrguLeP1z-6uyOu2QFwqKU5CIM,99
 fbgemm_gpu/utils/torch_library.py,sha256=ywsAHjbuwesj50LjEu99WkAH17FlaVgePZ9OmFg6YE4,4193
 list_versions/__init__.py,sha256=UmTeqCk-UJWFtlZQWvZao3xvui2w9E3X_JdOXVjRaNw,315
 list_versions/cli_run.py,sha256=CChZoXQ-tiKaWboXAYlPVJ5w8K5zAKiKcncA087I1sc,4508
-fbgemm_gpu_genai_nightly-2025.10.2.dist-info/METADATA,sha256=KiCiRdg53J2HiyUZMdm_uIZHb-E8u0QQj9uRSc9oRIM,2655
-fbgemm_gpu_genai_nightly-2025.10.2.dist-info/WHEEL,sha256=k9CVMKlTmOLLXq_OyiiJFbPd6UKfogV4yIUezgPmplE,108
-fbgemm_gpu_genai_nightly-2025.10.2.dist-info/top_level.txt,sha256=_2s1Aa08r_eDn0JP4FjOhzK09Q8bVlEI7q8pMep51UY,25
-fbgemm_gpu_genai_nightly-2025.10.2.dist-info/RECORD,,
+fbgemm_gpu_genai_nightly-2025.10.5.dist-info/METADATA,sha256=rTogIn95pgowlTBehwDMPRA5MmXP09AbRW_k4y12u84,2655
+fbgemm_gpu_genai_nightly-2025.10.5.dist-info/WHEEL,sha256=k9CVMKlTmOLLXq_OyiiJFbPd6UKfogV4yIUezgPmplE,108
+fbgemm_gpu_genai_nightly-2025.10.5.dist-info/top_level.txt,sha256=_2s1Aa08r_eDn0JP4FjOhzK09Q8bVlEI7q8pMep51UY,25
+fbgemm_gpu_genai_nightly-2025.10.5.dist-info/RECORD,,