fbgemm-gpu-nightly-cpu 2025.7.19__cp311-cp311-manylinux_2_28_aarch64.whl → 2026.1.29__cp311-cp311-manylinux_2_28_aarch64.whl

fbgemm_gpu/triton/jagged/triton_jagged_tensor_ops.py

@@ -9,7 +9,7 @@
 
 # pyre-ignore-all-errors[6]
 
-from typing import List, Optional, Tuple, Union
+from typing import Optional, Union
 
 import torch
 import triton  # @manual
@@ -472,7 +472,7 @@ def triton_jagged_to_dense_optimization_2d(
 # In FBGEMM it was computed by GPU but in triton currently has some compilation issue so we use CUP computation method as workaround
 # However in real-world case if we only dealing with 2d jagged tensor we don't need to use this function at all
 def _jagged_offsets_to_dense_indice(
-    offsets: List[torch.Tensor], dense_strides: List[int], dense_sizes: List[int]
+    offsets: list[torch.Tensor], dense_strides: list[int], dense_sizes: list[int]
 ) -> torch.Tensor:
 
     output_offset = torch.zeros(len(offsets[-1]) - 1, device="cpu", dtype=torch.int32)
@@ -532,8 +532,8 @@ def _jagged_offsets_to_dense_indice(
 # not be affected at all
 def jagged_to_dense(
     jagged_values: torch.Tensor,
-    jagged_offsets: List[torch.Tensor],
-    jagged_max_lengths: List[int],
+    jagged_offsets: list[torch.Tensor],
+    jagged_max_lengths: list[int],
     padding_value: float = 0.0,  # padding value currently use 0.0 as default value
     operation_function: Union[
         str, None
@@ -720,10 +720,10 @@ def triton_dense_to_jagged(
 
 def dense_to_jagged(
     dense: torch.Tensor,
-    jagged_offsets: List[torch.Tensor],
+    jagged_offsets: list[torch.Tensor],
     operation_function: Union[str, None] = None,
     operation_jagged_values: Union[torch.Tensor, None] = None,
-) -> Tuple[torch.Tensor, List[torch.Tensor]]:
+) -> tuple[torch.Tensor, list[torch.Tensor]]:
 
     thread_block_row_size = 32
     thread_block_col_size = 32
@@ -780,7 +780,7 @@ def dense_to_jagged(
 # jagged_tensor + dense -> dense
 def jagged_dense_elementwise_add_dense_output(
     jagged_values: Tensor,
-    jagged_offsets: List[Tensor],
+    jagged_offsets: list[Tensor],
     # pyre-fixme[2]: Parameter must be annotated.
     dense,
 ) -> Tensor:
@@ -800,8 +800,8 @@ def jagged_dense_elementwise_add_dense_output(
 
 # jagged_tensor + dense -> jagged_tensor
 def jagged_dense_elementwise_add_jagged_output(
-    jagged_values: Optional[Tensor], jagged_offsets: List[Tensor], dense: Tensor
-) -> Tuple[Tensor, List[Tensor]]:
+    jagged_values: Optional[Tensor], jagged_offsets: list[Tensor], dense: Tensor
+) -> tuple[Tensor, list[Tensor]]:
 
     return dense_to_jagged(
         dense,
@@ -813,8 +813,8 @@ def jagged_dense_elementwise_add_jagged_output(
 
 # jagged_tensor * dense -> jagged_tensor
 def jagged_dense_elementwise_mul_jagged_output(
-    jagged_values: Optional[Tensor], jagged_offsets: List[Tensor], dense: Tensor
-) -> Tuple[Tensor, List[Tensor]]:
+    jagged_values: Optional[Tensor], jagged_offsets: list[Tensor], dense: Tensor
+) -> tuple[Tensor, list[Tensor]]:
 
     return dense_to_jagged(
         dense,

fbgemm_gpu/triton/quantize.py

@@ -11,7 +11,6 @@ from typing import Union
 
 import torch
 import triton  # @manual
-
 import triton.language as tl  # @manual
 
 from .common import get_mx4_exp_bias, get_mx4_lookup_table, RoundingMode
@@ -238,7 +237,7 @@ def _kernel_quantize_mx4(
         # We readd fp32_exp_bias for compatibility with cuda dequant.
         tl.store(
             out + exp_offset,
-            (group_exp + FP32_EXP_BIAS).to(tl.int8),
+            (group_exp + FP32_EXP_BIAS).to(tl.uint8),
             # Prevent writing outside this chunk or the main array.
             mask=(exp_offset < OUTPUT_SIZE)
             & (exp_offset < (OUTPUT_CHUNK_SIZE * (pid + 1))),
@@ -575,7 +574,7 @@ def _kernel_dequantize_mx4(
         # Write final outputs.
         tl.store(
             out + output_offset,
-            scaled_fp32,
+            scaled_fp32.to(out.dtype.element_ty),
             # Mask values that are out of this chunk or the main array.
             mask=(output_offset < OUTPUT_SIZE)
             & (output_offset < OUTPUT_CHUNK_SIZE * (pid + 1)),
@@ -588,10 +587,14 @@ def _kernel_dequantize_mx4(
 
 
 def triton_dequantize_mx4(
-    a: torch.Tensor, group_size: int = 32, ebits: int = 2, mbits: int = 1
+    a: torch.Tensor,
+    group_size: int = 32,
+    ebits: int = 2,
+    mbits: int = 1,
+    output_dtype: torch.dtype = torch.float32,
 ) -> torch.Tensor:
     """
-    Dequantize a tensor from mx4 format to fp32.
+    Dequantize a tensor from mx4 format to fp32 or bf16.
 
     Args:
         a (Tensor): [M / 2 + M / group_size] MX4 tensor packed into int8 values
@@ -599,13 +602,15 @@ def triton_dequantize_mx4(
         group_size (int): Size of chunks that use the same shared exponent.
         ebits (int): Number of bits to use for exponent in target mx4 format.
         mbits (int): Number of bits to use for mantissa in target mx4 format.
+        output_dtype (torch.dtype): Output dtype (FP32 or BF16).
+            Defaults to torch.float32 for backward compatibility.
 
     Returns:
-        torch.Tensor: [M, K] dequantized fp32 tensor.
+        torch.Tensor: [M, K] dequantized tensor in the specified dtype.
     """
     # If given an empty shape, return an empty tensor.
     if a.numel() == 0:
-        return torch.empty(a.shape, device=a.device, dtype=torch.float32)
+        return torch.empty(a.shape, device=a.device, dtype=output_dtype)
     # View a as 2D for simplicity.
     orig_shape = a.shape
     a = a.flatten()
@@ -622,9 +627,9 @@ def triton_dequantize_mx4(
     # Use a lookup table to convert
     mx4_to_fp_values = get_mx4_lookup_table(ebits, mbits, a.device)
 
-    # Create output tensor.
+    # Create output tensor in target dtype.
     output_elems = num_groups * group_size
-    out = torch.empty([output_elems], device=a.device, dtype=torch.float)
+    out = torch.empty([output_elems], device=a.device, dtype=output_dtype)
     # Check if we need to use int64 for indexing.
     use_int64 = num_threads * groups_per_thread * group_size > 2**31 - 1
     # Invoke triton dequantization kernel over rows.

fbgemm_gpu/utils/filestore.py

@@ -11,7 +11,6 @@
 import io
 import logging
 import os
-import shutil
 from dataclasses import dataclass
 from pathlib import Path
 from typing import BinaryIO, Union
@@ -76,7 +75,12 @@ class FileStore:
             elif isinstance(raw_input, Path):
                 if not os.path.exists(raw_input):
                     raise FileNotFoundError(f"File {raw_input} does not exist")
-                shutil.copyfile(raw_input, filepath)
+                # Open the source file and destination file, and copy the contents
+                with open(raw_input, "rb") as src_file, open(
+                    filepath, "wb"
+                ) as dst_file:
+                    while chunk := src_file.read(4096):  # Read 4 KB at a time
+                        dst_file.write(chunk)
 
             elif isinstance(raw_input, io.BytesIO) or isinstance(raw_input, BinaryIO):
                 with open(filepath, "wb") as file:

fbgemm_gpu/utils/torch_library.py

@@ -8,7 +8,7 @@
 # pyre-strict
 
 import re
-from typing import Callable, Dict
+from typing import Callable
 
 import torch
 
@@ -112,7 +112,7 @@ class TorchLibraryFragment:
                 self.lib.impl(op_name, fn, dispatch_key)
 
     # pyre-ignore[24]
-    def register(self, op_name: str, functors: Dict[str, Callable]) -> None:
+    def register(self, op_name: str, functors: dict[str, Callable]) -> None:
         """
         Registers a set of dispatches for a defined operator.
 

fbgemm_gpu/utils/writeback_util.py

@@ -0,0 +1,124 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+
+
+def writeback_update_gradient(
+    indices: torch.Tensor,
+    offsets: torch.Tensor,
+    grad: torch.Tensor,
+    feature_table_map: list[int],
+) -> torch.Tensor:
+    """
+    Update gradient tensor by deduplicating indices across all features/tables.
+    For duplicate indices, only the first occurrence receives the gradient to achieve the assign purpose via gradient update
+
+    NOTE: This function is not supporting VBE yet
+
+    Args:
+        indices (torch.Tensor): Embedding indices tensor
+        offsets (torch.Tensor): Offsets tensor for batched embeddings
+        grad (torch.Tensor): Gradient tensor to be updated
+        feature_table_map (list[int]): Mapping from feature to table
+
+    Returns:
+        torch.Tensor: Updated gradient tensor with duplicates masked out
+    """
+    if indices.numel() == 0:
+        return grad[0]
+    # get num of feature to estimate batch size
+    num_of_tables = len(feature_table_map)
+    assert num_of_tables * indices.max() < torch.iinfo(indices.dtype).max
+    batch_size = offsets.shape[0] // num_of_tables
+    max_indices = indices.max()
+    non_empty_index = (offsets[1:] - offsets[:-1]).nonzero().flatten()
+    # disable dedup across different table
+    indices = ((offsets[non_empty_index]) // batch_size) * (1 + max_indices) + indices
+    grad = grad[0]
+    _, idx, counts = torch.unique(
+        indices, dim=0, sorted=True, return_inverse=True, return_counts=True
+    )
+    _, ind_sorted = torch.sort(idx, stable=True)
+    cum_sum = counts.cumsum(0)
+    cum_sum = torch.cat((torch.tensor([0]).to(indices.device), cum_sum[:-1]))
+    first_indicies = ind_sorted[cum_sum]
+    mask = torch.zeros_like(grad, device=grad.device)
+    original_index = non_empty_index[first_indicies]
+
+    mask[original_index] = grad[original_index]
+    return mask
+
+
+def writeback_update_gradient_first_feature_only(
+    indices: torch.Tensor,
+    offsets: torch.Tensor,
+    grad: torch.Tensor,
+    feature_table_map: list[int],
+) -> torch.Tensor:
+    """
+    Special case of writeback_update_gradient where gradient only needs to be updated for the first feature. Other features will be forward-only
+
+    NOTE: This function is not supporting VBE yet
+
+    Args:
+        indices (torch.Tensor): Embedding indices tensor
+        offsets (torch.Tensor): Offsets tensor for batched embeddings
+        grad (torch.Tensor): Gradient tensor to be updated
+        feature_table_map (list[int]): Mapping from feature to table
+
+    Returns:
+        torch.Tensor: Updated gradient tensor with duplicates masked out
+    """
+    num_of_tables = len(feature_table_map)
+    batch_size = (offsets.shape[0] - 1) // num_of_tables
+    shrink_indices = indices[: offsets[batch_size]]
+    if shrink_indices.numel() == 0 or indices.numel() == 0:
+        return grad[0]
+    assert num_of_tables * indices.max() < torch.iinfo(indices.dtype).max
+
+    grad = grad[0]
+    _, idx, counts = torch.unique(
+        shrink_indices, dim=0, sorted=True, return_inverse=True, return_counts=True
+    )
+    _, ind_sorted = torch.sort(idx, stable=True)
+    cum_sum = counts.cumsum(0)
+    cum_sum = torch.cat((torch.tensor([0]).to(shrink_indices.device), cum_sum[:-1]))
+    first_indicies = ind_sorted[cum_sum]
+    mask = torch.zeros_like(grad, device=grad.device)
+
+    mask[first_indicies] = grad[first_indicies]
+    return mask
+
+
+def writeback_gradient(
+    grad: torch.Tensor,
+    indices: torch.Tensor,
+    offsets: torch.Tensor,
+    feature_table_map: list[int],
+    writeback_first_feature_only: bool = False,
+) -> tuple[torch.Tensor]:
+    """
+    Compute deduplicated gradient for writeback operation.
+
+    Args:
+        grad (torch.Tensor): Gradient tensor to be updated
+        indices (torch.Tensor): Embedding indices tensor
+        offsets (torch.Tensor): Offsets tensor for batched embeddings
+        feature_table_map (list[int]): Mapping from feature to table
+        writeback_first_feature_only (bool): If True, only first feature will apply gradient update, other features will be read-only
+
+    Returns:
+        tuple[torch.Tensor]: Tuple containing the updated gradient tensor
+    """
+    if writeback_first_feature_only:
+        return (
+            writeback_update_gradient_first_feature_only(
+                indices, offsets, grad, feature_table_map
+            ),
+        )
+    else:
+        return (writeback_update_gradient(indices, offsets, grad, feature_table_map),)

fbgemm_gpu/uvm.py

@@ -12,6 +12,7 @@ from typing import Optional
 
 import torch
 
+# fmt:skip
 from fbgemm_gpu.enums import create_enums
 
 try:

{fbgemm_gpu_nightly_cpu-2025.7.19.dist-info → fbgemm_gpu_nightly_cpu-2026.1.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fbgemm_gpu_nightly-cpu
-Version: 2025.7.19
+Version: 2026.1.29
 Home-page: https://github.com/pytorch/fbgemm
 Author: FBGEMM Team
 Author-email: packages@pytorch.org
@@ -12,11 +12,11 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: BSD License
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Description-Content-Type: text/markdown
 Requires-Dist: numpy
 Dynamic: author

fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/RECORD

@@ -0,0 +1,135 @@
+fbgemm_gpu/__init__.py,sha256=JrSxUgY_diRl9kXapbyq3iteiB32D02CPan3stEFiAM,6434
+fbgemm_gpu/asmjit.so,sha256=j3yeBSR2egw60Od2aIs6-mcVEhCaL4OFXQUsU2h3oyk,526272
+fbgemm_gpu/batched_unary_embeddings_ops.py,sha256=pZqqUfvPIsaIo1CWX-_W087WQg-YEZuS0GNGoKFO_9c,2915
+fbgemm_gpu/enums.py,sha256=37ewGSfO1x7sO31ZkRiqV1yKuklfHXT5qZIxzeeGogo,755
+fbgemm_gpu/fbgemm.so,sha256=HibkS9eOXd0H4HnVQL8_sjCJhwFSwfXE8UnkXiFMMas,1378600
+fbgemm_gpu/fbgemm_gpu_config.so,sha256=m9ScFJOCn8P4YQT7evcFq1g75IO9X6VB3h1Eojm1A-k,67528
+fbgemm_gpu/fbgemm_gpu_embedding_inplace_ops.so,sha256=nKTMQeQptvT8uKuhdwCVFunWLjVFqQ8dKwawRIyaEbY,133400
+fbgemm_gpu/fbgemm_gpu_py.so,sha256=ha2K03pws-2S001OH7HyBOfpHsNlq3ekh_XasmHdEQg,4667832
+fbgemm_gpu/fbgemm_gpu_sparse_async_cumsum.so,sha256=MDL4JvJB-r72fFz_QDyqXhHn26eMff8XJh14cURL3Og,133200
+fbgemm_gpu/fbgemm_gpu_tbe_cache.so,sha256=Qy2xM7LWHfn3Xh78AfNbrMJyHmyvfA2-z0fH25Cw26M,331352
+fbgemm_gpu/fbgemm_gpu_tbe_common.so,sha256=QG3Y-63J_c62MIZQOESFYKZyiTwZpIIliNCY4UY47rk,463944
+fbgemm_gpu/fbgemm_gpu_tbe_index_select.so,sha256=2QEr7JKp-rGfkDpT4AwjSi18RqtlmumOymZJv_Cu21w,330064
+fbgemm_gpu/fbgemm_gpu_tbe_inference.so,sha256=FjQTkVJ_-E2zv7NiGLG43A-2MzIkmZku1LanCdwToGE,593608
+fbgemm_gpu/fbgemm_gpu_tbe_optimizers.so,sha256=PvFTSTJPOc4c0Znvub9EFh2C534elsn6Ryb7BYPic0U,67128
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward.so,sha256=iOi0axu_FJL-IWEeHgIqp7dkEA1wIUU-X5sKtxlt3uk,1127800
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward_dense.so,sha256=tglT4kIO_7ii8f9j4wMo9D80iue8lrdMrYqTxQPWZSk,67128
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward_gwd.so,sha256=RoWy1q3QHApZw9SIoTq-S_KrfDAmaOwGOABQfVs0weo,67128
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward_pt2.so,sha256=1uU9-vaWm5jRTmCSVZ5EHxmRQ3qMohCEjSkXXP2tumc,3291352
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward_split_host.so,sha256=ghqy1C0cu6s_Rp2SOP0egSgHa2y-zvZXPY9CORvoT8Q,67128
+fbgemm_gpu/fbgemm_gpu_tbe_training_backward_vbe.so,sha256=SG48X3jqnUV_H4XhmzQbHpcIpXTytALZ_oh-8UAeY_s,67128
+fbgemm_gpu/fbgemm_gpu_tbe_training_forward.so,sha256=hl-8Df6FJO86GsOCNBLMDfWLLq7VzuQLCbhYK6lHxkU,200160
+fbgemm_gpu/fbgemm_gpu_tbe_utils.so,sha256=qGGsojKO4pkIS4nwfoMI6XjFOwPGNwhuZlmGzJ0zJG4,133600
+fbgemm_gpu/metrics.py,sha256=TsurFLJf0nJvPDN7urWb4LMQlf5RgdWPTTTDO7S4wtI,5663
+fbgemm_gpu/permute_pooled_embedding_modules.py,sha256=B4_-TufcYZq__8ek92cKGjOIkqkZO47pQMkQSDKJIWo,5141
+fbgemm_gpu/permute_pooled_embedding_modules_split.py,sha256=f3VJvH_kw9Ltd_DXtaf_PJPHmlmEWrQgzQ7MDkhh5Nw,2746
+fbgemm_gpu/quantize_comm.py,sha256=gtp0zWYdobAnG6Xe8vZuTu0ZWKDu2hWmsmvV1zA09UQ,11992
+fbgemm_gpu/quantize_utils.py,sha256=sROgIdOrAjQT5_CmFafg40GMo0-pe4d56bAZTI57548,10243
+fbgemm_gpu/runtime_monitor.py,sha256=YXRUv6nXCsoTgh5_RzailTGvCYzwoYDb-eR4rlGwtaw,7619
+fbgemm_gpu/sparse_ops.py,sha256=lJ55cgpP7MoNKo6l6QTDgvfEx8ftkJQrj8kUiIHWBvY,52183
+fbgemm_gpu/split_embedding_configs.py,sha256=bEFnWzCGoHFfJIfzyusmSnSSl9tTd5C8z_j176SS0w0,16584
+fbgemm_gpu/split_embedding_inference_converter.py,sha256=TpGZUXLA0rYemPT37Y0zmZnMIzjHogkRcL0gIhggbM8,7063
+fbgemm_gpu/split_embedding_optimizer_ops.py,sha256=wXuGazClBMk62yL_r9udUIKaPgQP7SlkSb5ugB75wrQ,711
+fbgemm_gpu/split_embedding_utils.py,sha256=Gb40ZKeATxIKEKI3aVQMgDDBanNpKMc53Z43mnzdR_I,851
+fbgemm_gpu/split_table_batched_embeddings_ops.py,sha256=_MIp6uHYHLn4GxGdrGsfddfSsZ2Z9mjsYIrih3ncI1I,2339
+fbgemm_gpu/split_table_batched_embeddings_ops_common.py,sha256=_uUplpcyQOQuxqv8-HV94VUM5lG8e3aGWltXhOgICQc,19294
+fbgemm_gpu/split_table_batched_embeddings_ops_inference.py,sha256=dGC85xjQiRUrequBibSf9oMAVHT5Q49zsVo2zW4n_88,81679
+fbgemm_gpu/split_table_batched_embeddings_ops_training.py,sha256=uCPngWxxC5OQhJv7o6aGs8xf3WlRSrdRHbpCBlPbIuE,191511
+fbgemm_gpu/split_table_batched_embeddings_ops_training_common.py,sha256=jofAN2UB_iSk53Id6MBvn9Bi3Qxw67IL0_VE_EHlw_Q,7593
+fbgemm_gpu/ssd_split_table_batched_embeddings_ops.py,sha256=2TTKsF5yaROTaI69YdCIt8hr_v2TDEo8EraZ0QXNBxc,717
+fbgemm_gpu/tbe_input_multiplexer.py,sha256=MbZF8aZdm_kV-JRMaooeZrqlh6Pn5IuNkSXBXODp-LE,3062
+fbgemm_gpu/uvm.py,sha256=5kOlOauKhOmj-B8AUqpal7riMwTfmsL0HGrh1Wweb80,1058
+fbgemm_gpu/config/__init__.py,sha256=yN0KAneCICgF2BTfOYGsd0qU1PvZX_6msC6YHHZKLMg,292
+fbgemm_gpu/config/feature_list.py,sha256=hhDNkkafd-Oetvuqv9ylBVTNM-lKPi029mpRqq-JZCA,2467
+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
+fbgemm_gpu/docs/jagged_tensor_ops.py,sha256=g8MA8ezTXiqingvk1DlTZJDQcmcCZPXpshuiWxS34F0,7380
+fbgemm_gpu/docs/merge_pooled_embedding_ops.py,sha256=oJLgSgZQmhsyGLbTmZTxNgQrk65_3E8xSJaWSj_Jbo8,1102
+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/target.default.json.py,sha256=_BcuMA1hCJ_Jtf08E7O8t-R8A5HiRXHH3Z9rpgCq66U,79
+fbgemm_gpu/quantize/__init__.py,sha256=yPUCmLhNdahHFireHPQMmmiRp3g6W2dkIl5MB51M6SU,942
+fbgemm_gpu/quantize/quantize_ops.py,sha256=C3SN79GcL7fczzoFkxUojm6cGkvvI4iWttkGN4LFQcM,2239
+fbgemm_gpu/sll/__init__.py,sha256=nLFeTiRed6A5STRi_EgHCyNoik0zhXUk2db5kTmMUNU,4221
+fbgemm_gpu/sll/cpu/__init__.py,sha256=glsukNpXtf47VRIdBktILD-4CmVcf4621SGB55lT_ho,2692
+fbgemm_gpu/sll/cpu/cpu_sll.py,sha256=2XyvpZ_UgSThCzUmFDQbjUdLFbz0AvhvqPR_suUcyd8,27866
+fbgemm_gpu/sll/meta/__init__.py,sha256=2sMcD67XGsweBZ-UV2AEJmM4ELPsHeRAYED6kqfgAd4,1077
+fbgemm_gpu/sll/meta/meta_sll.py,sha256=Jk14EOW9VPFwawD7Bwky0R0A5rmbcLWMo52oH8J6Koc,8305
+fbgemm_gpu/sll/triton/__init__.py,sha256=ndvZ5OO81KP65HopJql91R9y_5fC88WnNIGYxCAVKwM,4099
+fbgemm_gpu/sll/triton/common.py,sha256=hISlX4Y-7FtGof-Xx4_B8-2vlF27F9t4p2qyLMUnJ8A,798
+fbgemm_gpu/sll/triton/triton_dense_jagged_cat_jagged_out.py,sha256=J9qOqjNJ72LUBqs-pGI9wrFzzzBpsZ5fzYjgfKc2YhY,1885
+fbgemm_gpu/sll/triton/triton_jagged2_to_padded_dense.py,sha256=lxIYe2MUde2qxLVO_aeTm34fDsMIz8ZkIjyx9Xk-YkE,5923
+fbgemm_gpu/sll/triton/triton_jagged_bmm.py,sha256=bZIgk-GBdP8lPOoAOiIvO-9IE86B5Ejljmnh6-IuQeA,11785
+fbgemm_gpu/sll/triton/triton_jagged_bmm_jagged_out.py,sha256=hccLxsKoSZKiWid5P_yl-IVdBSXw1Rt0WeiRsjLD2Iw,13864
+fbgemm_gpu/sll/triton/triton_jagged_dense_elementwise_add.py,sha256=FRZ7vqaTIxVWkztr50q94Uic209e2KriLgF-3PQD6QM,1603
+fbgemm_gpu/sll/triton/triton_jagged_dense_elementwise_mul_jagged_out.py,sha256=9R7BOOe8SJiko1PgbiuHlFyPKtGaaCFSlZ1RaEQyICE,4198
+fbgemm_gpu/sll/triton/triton_jagged_dense_flash_attention.py,sha256=qJvMCRUqMOwL_kxYs1fd5QvYdbjaGeoBy9ovNGpjMws,22779
+fbgemm_gpu/sll/triton/triton_jagged_flash_attention_basic.py,sha256=po9Nx4uAGVu_YIZ9CWvrmzSwxDsnDuNAtnk9VR7-Ems,17750
+fbgemm_gpu/sll/triton/triton_jagged_self_substraction_jagged_out.py,sha256=VaOIxQn4Obvna2Co5VNDGILCDfKuYwkhVxK2oCi5mPI,1754
+fbgemm_gpu/sll/triton/triton_jagged_softmax.py,sha256=odN66XGPc5VWmMZ34FRBsodpUtbpEILDpOgPtpCNrY4,14225
+fbgemm_gpu/sll/triton/triton_multi_head_jagged_flash_attention.py,sha256=nEo5I-bba1XlG59qoACGB18OrA1LISs-e7Lasgys1s8,19572
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/__init__.py,sha256=kHLPaFr6UcvXDtdDQuF9CP-fvRNdniOORrG5B8O8SmU,6917
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_adagrad.py,sha256=V8CXfcyi5cXSP4-EbXGAq8NRXZdibZQSbPoFLHEcmo8,9733
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_adam.py,sha256=Bm0R9a6zL6LTEavWsRgkQilPW7aWg3SBOyE-S5AV8B8,12735
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_args.py,sha256=k7ZvSHi8fEsZP2GjofNIEFO9mdaQbQxINIhDbPdol0U,2830
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_args_ssd.py,sha256=pOhpRdDutSGpOZW5CylR4IIxljYpodizlLUbrO7PoF8,2909
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_lamb.py,sha256=GyRwkpONuthj_MG0PEbDpkiTMUpQ6ffg1xo5NgGbpGU,10720
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_lars_sgd.py,sha256=xHxf8neshHuE_6ybtAOrVFFMnwxfPQG11iuF0QIItVs,10285
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_none.py,sha256=7xOrQArbnUvGR2xMMRZ5gEsxoKRbDXi5ufxd-55b24g,9414
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_partial_rowwise_adam.py,sha256=7V7BdQCUZPOp8gmxrQvTfeinULf_uQppdFe7t9POBZ8,10425
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_partial_rowwise_lamb.py,sha256=oRjJ302FMr1O9ibFvNtXqn3i-lpmNDh-3JslMstBAxY,10425
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_rowwise_adagrad.py,sha256=wQyjKE5xjZNDyNwQmiwuviMrgtEv2QX-MQMDZ8St2_A,10182
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_rowwise_adagrad_ssd.py,sha256=YE6RgV8By8FGUxnzduUrjJdNI8j2JOmdEuWcCAikLMk,11523
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_rowwise_adagrad_with_counter.py,sha256=LZLuTucNYd2wlzfC4pU6339SmRZJiKIWlYwFDU1VFt4,12172
+fbgemm_gpu/split_embedding_codegen_lookup_invokers/lookup_sgd.py,sha256=N32H1lUbbWModjDk_Ci8iF8P0hmlSmemmJynGQhuBGI,9195
+fbgemm_gpu/split_embedding_optimizer_codegen/optimizer_args.py,sha256=xWSmk56JgoYfO8eiiK4BP9Brbhixs4tUAMeWp5TPZ30,956
+fbgemm_gpu/split_embedding_optimizer_codegen/split_embedding_optimizer_rowwise_adagrad.py,sha256=bjrbKAypa-FnOIVKH-IUnWP1Jhlu0lk1SopZ0KLFVdo,6623
+fbgemm_gpu/tbe/__init__.py,sha256=fE0IHi1JJpxsNVBNzWNee2thrNXFFRhY94c80RxNSIE,231
+fbgemm_gpu/tbe/bench/__init__.py,sha256=TyUVsIH4p-RtFaXAKppYoaWbf9UTjCTUpnIV7RD_O5E,1653
+fbgemm_gpu/tbe/bench/bench_config.py,sha256=xgtlGLCeZVW6jBYwkKsiQeCslCrWDgJbV2NLLwCRSn4,5452
+fbgemm_gpu/tbe/bench/bench_runs.py,sha256=K4HRUcsX4BWqtrYwinZSXjnjNDFkvpoEdQmv-6rz7Tk,23518
+fbgemm_gpu/tbe/bench/benchmark_click_interface.py,sha256=ofcGsiTUj3_Ml7JSsqg_LcMw3CV-6ypmlRWAUmT_cjc,6941
+fbgemm_gpu/tbe/bench/eeg_cli.py,sha256=B3QOZhtycMDwHMG3dFKnlFuWOqYRCF3RCozEQfrqv8o,3580
+fbgemm_gpu/tbe/bench/embedding_ops_common_config.py,sha256=zdL_ve1Ga6ziU5LjfnzJXOBOIqtCjLlhSrlGfa42H9w,4978
+fbgemm_gpu/tbe/bench/eval_compression.py,sha256=ulFMaNZF2g_vfkXLWZSh02ibotg1zpTz3swVU484mzU,3486
+fbgemm_gpu/tbe/bench/reporter.py,sha256=ZK5RFolUmZEcsEaife270_iOdXAQD5EjTUkuxctnAbY,804
+fbgemm_gpu/tbe/bench/tbe_data_config.py,sha256=d724L4Is3Bo2D5reglgsBs7H6ezLFDrQUbTP5tsnPEQ,8509
+fbgemm_gpu/tbe/bench/tbe_data_config_bench_helper.py,sha256=c-IwLbx04Qbqxzfcn9N4U9Eo9QnmgbBN6HxJYAJwvMw,11311
+fbgemm_gpu/tbe/bench/tbe_data_config_loader.py,sha256=fSdtEAnKu6r56mHMtMJIHo-S6m3vC4cPRyXJKKUevzc,11996
+fbgemm_gpu/tbe/bench/tbe_data_config_param_models.py,sha256=I9dozlJAW_XzuopyJapJ4gmDkLU0YSUz2znugiLZRMg,6203
+fbgemm_gpu/tbe/bench/utils.py,sha256=C0GTTomJO3r9LVfbpzlkudxoA_3QyeMdM-7zM-YOAHA,6716
+fbgemm_gpu/tbe/cache/__init__.py,sha256=lrYwhvqX2eWN0vAPe89HYgMW_O1vccoOcoFHJ9cyM-s,398
+fbgemm_gpu/tbe/cache/kv_embedding_ops_inference.py,sha256=VmG9EennGcq2By8Tj8VkFsJG0oOCGw8EhlPo8-t--Fk,14604
+fbgemm_gpu/tbe/cache/split_embeddings_cache_ops.py,sha256=vZHj7KIe1DoJDy5eft29XtGg6I-tRx60tjKOcTHRAYI,1321
+fbgemm_gpu/tbe/ssd/__init__.py,sha256=wzfMT10cp_dqK2lrebC449hOdexBnizcf_98lA1NyHs,483
+fbgemm_gpu/tbe/ssd/common.py,sha256=zecFfJCcQIwNYbaGoI44Q8rGCskvtmOmc1zxqYHS7Tg,1055
+fbgemm_gpu/tbe/ssd/inference.py,sha256=MwSXP4l2fJUSQJRPu9-bqU08Kg9-0ux8uA5UPSabW3M,22812
+fbgemm_gpu/tbe/ssd/training.py,sha256=2CFA4KmA9IfcpX14K4MlzBuSRPD9h5NM1M7TqepH6vA,212168
+fbgemm_gpu/tbe/ssd/utils/__init__.py,sha256=5DgmR2HA6NtmYh2ddkUgpDsZ6a7hF0DPedA1gMpdh18,250
+fbgemm_gpu/tbe/ssd/utils/partially_materialized_tensor.py,sha256=SFg2-29b-i49LWm-FlaWUkTz2XzXbicYi_AzVj4jKNE,7601
+fbgemm_gpu/tbe/stats/__init__.py,sha256=on29iDtq7cVNh90JR9aeFNG-K9DDoYq0JryzoplL49I,322
+fbgemm_gpu/tbe/stats/bench_params_reporter.py,sha256=_lA4peKXI0GCWsZHJ7IUKlUHU98CA-gVoOc-uhRfcoY,13233
+fbgemm_gpu/tbe/utils/__init__.py,sha256=rlXFm-kTByFZO4SS5C5zMzANRiQmM1NT__eWBayncYg,549
+fbgemm_gpu/tbe/utils/common.py,sha256=KBCyBT-7ShhTRRd1Rs5sEU4g8JggEM7Es6wQ0qhWY-o,1313
+fbgemm_gpu/tbe/utils/offsets.py,sha256=DDWwGaQsVZbhaEZ_fRxxeY8ndLc7IORPZrx61eOqwJc,1904
+fbgemm_gpu/tbe/utils/quantize.py,sha256=EdYh9FS_kMsvCWPuvNms4uSE9de_3cQNo_DCScGG3zI,9166
+fbgemm_gpu/tbe/utils/requests.py,sha256=_lxGVt2J0tEmG7aXv24BMrvfdK6HuvMPlPZHWsF_EDI,18038
+fbgemm_gpu/triton/__init__.py,sha256=kPn_Ye6J9DAzWtqi76KYGwfKSqw0IhqG3Bir5aUpkWM,658
+fbgemm_gpu/triton/common.py,sha256=tsK56Dom_XSb5kXuoN0KnGAWlC5HWV7Ook--a59UHdI,2130
+fbgemm_gpu/triton/quantize.py,sha256=I0pxyfIx04zyq55x4Pvj-28Cb2ZeF-SGtFhAymFagkg,27073
+fbgemm_gpu/triton/quantize_ref.py,sha256=q4RBmFaqPVPELU52lbSgB0n26Aun7apeK7bRF2MWS80,11553
+fbgemm_gpu/triton/jagged/__init__.py,sha256=om0yhjuzKuE1UQakFMWHsXN4WNb8mvNkZtYofQ8hdn4,246
+fbgemm_gpu/triton/jagged/triton_jagged_tensor_ops.py,sha256=F2eQWjkWMR5RWQ48oIr-8OU_CRZyLazDpT7DFrDWS6g,29871
+fbgemm_gpu/utils/__init__.py,sha256=JQQNdcTTaEU6ptK-OW-ZQBwTFxEZZpWOtBXWwEZm39o,354
+fbgemm_gpu/utils/filestore.py,sha256=oVtbKGaPQki1JgbJCkrkElukOFVyxntQpSC0lYBKgho,6455
+fbgemm_gpu/utils/loader.py,sha256=1hCEhNvkflniH46fGcrguLeP1z-6uyOu2QFwqKU5CIM,990
+fbgemm_gpu/utils/torch_library.py,sha256=ywsAHjbuwesj50LjEu99WkAH17FlaVgePZ9OmFg6YE4,4193
+fbgemm_gpu/utils/writeback_util.py,sha256=PyVbHp1EuF-GKrJv_CTP6B50Z0oBblXKucf7Rhd6KKY,4614
+list_versions/__init__.py,sha256=UmTeqCk-UJWFtlZQWvZao3xvui2w9E3X_JdOXVjRaNw,315
+list_versions/cli_run.py,sha256=BCRaJvjVFBFmD5WPdjC_yJwlLv1w_TYOe3eYlf_9ZMo,4506
+fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/METADATA,sha256=sqUYIVBwodRVxysq3jEToUNFX12vtC4tZenZnKnynjo,2654
+fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/WHEEL,sha256=IaW-egZU3n4QvS-XsoO31KhIl6_BixcQGgBPEoTC6GI,109
+fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/top_level.txt,sha256=_2s1Aa08r_eDn0JP4FjOhzK09Q8bVlEI7q8pMep51UY,25
+fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/RECORD,,

fbgemm_gpu_nightly_cpu-2026.1.29.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+fbgemm_gpu
+list_versions

fbgemm_gpu/docs/version.py → list_versions/__init__.py

@@ -1,4 +1,3 @@
-
 #!/usr/bin/env python3
 # Copyright (c) Meta Platforms, Inc. and affiliates.
 # All rights reserved.
@@ -6,6 +5,8 @@
 # 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.7.19"
-__target__: str = "default"
-__variant__: str = "cpu"
+# pyre-strict
+
+from .cli_run import CLI, CLIOutput
+
+__all__ = ["CLI", "CLIOutput"]

list_versions/cli_run.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-strict
+
+import logging
+import subprocess
+from datetime import datetime
+from typing import Union
+
+import click
+import pandas as pd
+import torch
+
+
+class CLIOutput:
+    def __init__(
+        self,
+        cli: str = "",
+        stdout: str = "",
+        stderr: str = "",
+        returncode: int = 0,
+        timestamp: str = "2025-01-01T20:00:00.00000",
+        visible: bool = True,
+    ) -> None:
+        self._cli = cli
+        self._stdout = stdout
+        self._stderr = stderr
+        self._returncode = returncode
+        self._timestamp = timestamp
+        self._visible = visible
+
+    def to_dict(self) -> dict[str, Union[int, str]]:
+        return {
+            "cli": self._cli,
+            "stdout": self._stdout,
+            "stderr": self._stderr,
+            "returncode": self._returncode,
+            "timestamp": self._timestamp,
+            "visible": self._visible,
+        }
+
+
+class CLI:
+    def __init__(self) -> None:
+        pd.options.display.max_rows
+        pd.set_option("display.max_colwidth", None)
+        self._cli_outputs: list[CLIOutput] = [
+            CLIOutput(
+                cli="python –c “import torch; print(torch.__version__)”",
+                stdout="{}".format(torch.__version__),
+                stderr="",
+                returncode=0,
+                timestamp=datetime.now().isoformat(),
+                visible=True,
+            )
+        ]
+
+    def run(
+        self,
+        cli: Union[str, list[str]],
+        visible: bool = True,
+        input: str = "",
+        capture_output: bool = True,
+    ) -> CLIOutput:
+        if isinstance(cli, str):
+            cli = cli.split()
+        result = CLIOutput()
+        try:
+            completed = subprocess.run(
+                cli, text=True, check=False, capture_output=capture_output, input=input
+            )
+            result = CLIOutput(
+                cli=" ".join(cli),
+                stdout=completed.stdout,
+                stderr=completed.stderr,
+                returncode=completed.returncode,
+                timestamp=datetime.now().isoformat(),
+                visible=visible,
+            )
+            if visible:
+                self._cli_outputs.append(result)
+        except Exception as e:
+            logging.error(f'For cli {" ".join(cli)} we got exception {e}')
+            result = CLIOutput(
+                cli=" ".join(cli),
+                stdout="",
+                stderr=str(e),
+                returncode=-1,
+                visible=visible,
+                timestamp=datetime.now().isoformat(),
+            )
+            if visible:
+                self._cli_outputs.append(result)
+        return result
+
+    def run_piped(self, clis: list[str]) -> None:
+        the_input = ""
+        for cli in clis[:-1]:
+            result = self.run(
+                cli=cli, visible=False, input=the_input, capture_output=True
+            )
+            the_input = result._stdout
+        self.run(cli=clis[-1], visible=True, input=the_input, capture_output=True)
+
+    def to_dataframe(self) -> pd.DataFrame:
+        return pd.DataFrame([output.to_dict() for output in self._cli_outputs])
+
+    def save(self, filename: str, format: str = "csv") -> None:
+        df = self.to_dataframe()
+        if format == "csv":
+            df.to_csv(filename, index=False)
+        elif format == "json":
+            df.to_json(filename, orient="records", lines=True)
+        else:
+            raise ValueError(f"Invalid format {format} : must be one of 'csv', 'json'")
+
+
+@click.command()
+@click.option("--json", default="")
+@click.option("--csv", default="")
+def cli_run(
+    json: str,
+    csv: str,
+) -> None:
+    cli = CLI()
+
+    the_rpm = "rpm -qa"
+    the_grep1 = "grep -E ^amdgpu-(dkms|kmod)"
+    the_grep2 = "grep -v firmware"
+    the_sed1 = "sed -E s/^[^-]-[^-]-//"
+    the_sed2 = "sed -E s/.[^.].[^.]$//"
+    cli.run_piped([the_rpm, the_grep1, the_grep2, the_sed1, the_sed2])
+
+    cli.run("uname -r")
+
+    cli.run("fw-util all --version")
+
+    cli.run("amd-smi firmware")
+    cli.run("amd-smi version")
+    cli.run("amd-smi static")
+
+    if len(csv):
+        cli.save(csv)
+
+    if len(json):
+        cli.save(json, format="json")
+
+    print(cli.to_dataframe())
+
+
+def main() -> None:
+    cli_run()
+
+
+if __name__ == "__main__":
+    main()