From 31881d9e10e690617586fb566248a66f8a0907a1 Mon Sep 17 00:00:00 2001 From: Zhouyu Li Date: Mon, 16 Jun 2025 10:50:50 -0700 Subject: [PATCH 1/3] OSS TorchRec Internal MPZCH modules (#3017) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Summary: Pull Request resolved: https://github.com/pytorch/torchrec/pull/3017 ### Major changes - Copy the following files from `fb` to corresponding location in the `torchrec` repository - `fb/distributed/hash_mc_embedding.py → torchrec/distributed/hash_mc_embedding.py` - `fb/modules/hash_mc_evictions.py → torchrec/modules/hash_mc_evictions.py` - `fb/modules/hash_mc_metrics.py → torchrec/modules/hash_mc_metrics.py` - `fb/modules/hash_mc_modules.py → torchrec/modules/hash_mc_modules.py` - `fb/modules/tests/test_hash_mc_evictions.py → torchrec/modules/tests/test_hash_mc_evictions.py` - `fb/modules/tests/test_hash_mc_modules.py → torchrec/modules/tests/test_hash_mc_modules.py` - Create a `test_hash_zch_mc.py` file in `torchrec/distributed/tests` folder following the `test_quant_mc_embedding.py` in `torchrec/fb/distributed/tests`. - trimmed quantization and inference codes, and only kept the training part. - rewire the related packages from `torchrec.fb` to `torchrec` - Update `BUCK` files in related folders - Update the affected repos to use `torchrec` modules instead of the modules in `torchrec.fb` - Update `/modules/hash_mc_metrics.py` - Replace the tensorboard module with a local file logger in `hash_mc_metrics.py` module - Update the license declaration headers for the four OSS files ### ToDos after landing this Diff - Clean the duplicated `hash_mc_modules.py` file in the `fb` folder for safe landing. Differential Revision: D76476676 --- torchrec/distributed/hash_mc_embedding.py | 91 +++ .../distributed/tests/test_hash_zch_mc.py | 228 ++++++ torchrec/modules/hash_mc_evictions.py | 257 +++++++ torchrec/modules/hash_mc_metrics.py | 200 ++++++ torchrec/modules/hash_mc_modules.py | 580 ++++++++++++++++ .../modules/tests/test_hash_mc_evictions.py | 72 ++ .../modules/tests/test_hash_mc_modules.py | 650 ++++++++++++++++++ 7 files changed, 2078 insertions(+) create mode 100644 torchrec/distributed/hash_mc_embedding.py create mode 100644 torchrec/distributed/tests/test_hash_zch_mc.py create mode 100644 torchrec/modules/hash_mc_evictions.py create mode 100644 torchrec/modules/hash_mc_metrics.py create mode 100644 torchrec/modules/hash_mc_modules.py create mode 100644 torchrec/modules/tests/test_hash_mc_evictions.py create mode 100644 torchrec/modules/tests/test_hash_mc_modules.py diff --git a/torchrec/distributed/hash_mc_embedding.py b/torchrec/distributed/hash_mc_embedding.py new file mode 100644 index 000000000..4171e1092 --- /dev/null +++ b/torchrec/distributed/hash_mc_embedding.py @@ -0,0 +1,91 @@ +#!/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 as logger +from collections import defaultdict +from typing import Dict, List + +import torch +from torchrec.distributed.quant_state import WeightSpec +from torchrec.distributed.types import ShardingType +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule + + +def sharded_zchs_buffers_spec( + sharded_model: torch.nn.Module, +) -> Dict[str, WeightSpec]: + # OUTPUT: + # Example: + # "main_module.module.ec_in_task_arch_hash._decoupled_embedding_collection._mcec_lookup.0.0._mcc_remapper.zchs.viewer_rid_duplicate._hash_zch_identities", [0, 0], [500, 1]) + # "main_module.module.ec_in_task_arch_hash._decoupled_embedding_collection._mcec_lookup.0.1._mcc_remapper.zchs.viewer_rid_duplicate._hash_zch_identities", [500, 0], [1000, 1]) + + # 'main_module.module.ec_in_task_arch_hash._decoupled_embedding_collection._mcec_lookup.0.0._mcc_remapper.zchs.viewer_rid_duplicate._hash_zch_identities': WeightSpec(fqn='main_module.module.ec_in_task_arch_hash._ d_embedding_collection._managed_collision_collection.viewer_rid_duplicate._hash_zch_identities' + def _get_table_names( + sharded_module: torch.nn.Module, + ) -> List[str]: + table_names: List[str] = [] + for _, module in sharded_module.named_modules(): + type_name: str = type(module).__name__ + if "ShardedMCCRemapper" in type_name: + for table_name in module._tables: + if table_name not in table_names: + table_names.append(table_name) + return table_names + + def _get_unsharded_fqn_identities( + sharded_module: torch.nn.Module, + fqn: str, + table_name: str, + ) -> str: + for module_fqn, module in sharded_module.named_modules(): + type_name: str = type(module).__name__ + if "ManagedCollisionCollection" in type_name: + if table_name in module._table_to_features: + return f"{fqn}.{module_fqn}._managed_collision_modules.{table_name}.{HashZchManagedCollisionModule.IDENTITY_BUFFER}" + logger.info(f"did not find table {table_name} in module {fqn}") + return "" + + ret: Dict[str, WeightSpec] = defaultdict() + for module_fqn, module in sharded_model.named_modules(): + type_name: str = type(module).__name__ + if "ShardedQuantManagedCollisionEmbeddingCollection" in type_name: + sharding_type = ShardingType.ROW_WISE.value + table_name_to_unsharded_fqn_identities: Dict[str, str] = {} + for subfqn, submodule in module.named_modules(): + type_name: str = type(submodule).__name__ + if "ShardedMCCRemapper" in type_name: + for table_name in submodule.zchs.keys(): + # identities tensor has only one column + shard_offsets: List[int] = [ + submodule._shard_metadata[table_name][0], + 0, + ] + shard_sizes: List[int] = [ + submodule._shard_metadata[table_name][1], + 1, + ] + if table_name not in table_name_to_unsharded_fqn_identities: + table_name_to_unsharded_fqn_identities[table_name] = ( + _get_unsharded_fqn_identities( + module, module_fqn, table_name + ) + ) + unsharded_fqn_identities: str = ( + table_name_to_unsharded_fqn_identities[table_name] + ) + # subfqn contains the index of sharding, so no need to add it specifically here + sharded_fqn_identities: str = ( + f"{module_fqn}.{subfqn}.zchs.{table_name}.{HashZchManagedCollisionModule.IDENTITY_BUFFER}" + ) + ret[sharded_fqn_identities] = WeightSpec( + fqn=unsharded_fqn_identities, + shard_offsets=shard_offsets, + shard_sizes=shard_sizes, + sharding_type=sharding_type, + ) + return ret diff --git a/torchrec/distributed/tests/test_hash_zch_mc.py b/torchrec/distributed/tests/test_hash_zch_mc.py new file mode 100644 index 000000000..7cf9906d1 --- /dev/null +++ b/torchrec/distributed/tests/test_hash_zch_mc.py @@ -0,0 +1,228 @@ +#!/usr/bin/env python3 +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +#!/usr/bin/env python3 + +# pyre-strict + +import copy +import multiprocessing +import unittest +from typing import Any, Dict, List, Optional, Tuple, Union + +import torch +from pyre_extensions import none_throws +from torch import nn +from torchrec import ( + EmbeddingCollection, + EmbeddingConfig, + JaggedTensor, + KeyedJaggedTensor, + KeyedTensor, +) +from torchrec.distributed import ModuleSharder, ShardingEnv +from torchrec.distributed.mc_modules import ManagedCollisionCollectionSharder + +from torchrec.distributed.shard import _shard_modules +from torchrec.distributed.sharding_plan import ( + construct_module_sharding_plan, + EmbeddingCollectionSharder, + ManagedCollisionEmbeddingCollectionSharder, + row_wise, +) +from torchrec.distributed.test_utils.multi_process import ( + MultiProcessContext, + MultiProcessTestBase, +) +from torchrec.distributed.types import ShardingPlan +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection +from torchrec.modules.mc_modules import ManagedCollisionCollection + +BASE_LEAF_MODULES = [ + "IntNBitTableBatchedEmbeddingBagsCodegen", + "HashZchManagedCollisionModule", +] + + +class SparseArch(nn.Module): + def __init__( + self, + tables: List[EmbeddingConfig], + device: torch.device, + buckets: int, + return_remapped: bool = False, + input_hash_size: int = 4000, + is_inference: bool = False, + ) -> None: + super().__init__() + self._return_remapped = return_remapped + + mc_modules = {} + mc_modules["table_0"] = HashZchManagedCollisionModule( + is_inference=is_inference, + zch_size=(tables[0].num_embeddings), + input_hash_size=input_hash_size, + device=device, + total_num_buckets=buckets, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=["feature_0"], + single_ttl=1, + ), + ) + + mc_modules["table_1"] = HashZchManagedCollisionModule( + is_inference=is_inference, + zch_size=(tables[1].num_embeddings), + device=device, + input_hash_size=input_hash_size, + total_num_buckets=buckets, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=["feature_1"], + single_ttl=1, + ), + ) + + self._mc_ec: ManagedCollisionEmbeddingCollection = ( + ManagedCollisionEmbeddingCollection( + EmbeddingCollection( + tables=tables, + device=device, + ), + ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=tables, + ), + return_remapped_features=self._return_remapped, + ) + ) + + def forward( + self, kjt: KeyedJaggedTensor + ) -> Tuple[ + Union[KeyedTensor, Dict[str, JaggedTensor]], Optional[KeyedJaggedTensor] + ]: + return self._mc_ec(kjt) + + +class TestHashZchMcEmbedding(MultiProcessTestBase): + # pyre-ignore + @unittest.skipIf(torch.cuda.device_count() <= 1, "Not enough GPUs, skipping") + def test_hash_zch_mc_ec(self) -> None: + + WORLD_SIZE = 2 + + embedding_config = [ + EmbeddingConfig( + name="table_0", + feature_names=["feature_0"], + embedding_dim=8, + num_embeddings=16, + ), + EmbeddingConfig( + name="table_1", + feature_names=["feature_1"], + embedding_dim=8, + num_embeddings=32, + ), + ] + + train_input_per_rank = [ + KeyedJaggedTensor.from_lengths_sync( + keys=["feature_0", "feature_1"], + values=torch.LongTensor( + list(range(1000, 1025)), + ), + lengths=torch.LongTensor([1] * 8 + [2] * 8), + weights=None, + ), + KeyedJaggedTensor.from_lengths_sync( + keys=["feature_0", "feature_1"], + values=torch.LongTensor( + list(range(25000, 25025)), + ), + lengths=torch.LongTensor([1] * 8 + [2] * 8), + weights=None, + ), + ] + train_state_dict = multiprocessing.Manager().dict() + + # Train Model with ZCH on GPU + self._run_multi_process_test( + callable=_train_model, + world_size=WORLD_SIZE, + tables=embedding_config, + num_buckets=2, + kjt_input_per_rank=train_input_per_rank, + sharder=ManagedCollisionEmbeddingCollectionSharder( + EmbeddingCollectionSharder(), + ManagedCollisionCollectionSharder(), + ), + return_dict=train_state_dict, + backend="nccl", + ) + + +def _train_model( + tables: List[EmbeddingConfig], + num_buckets: int, + rank: int, + world_size: int, + kjt_input_per_rank: List[KeyedJaggedTensor], + sharder: ModuleSharder[nn.Module], + backend: str, + return_dict: Dict[str, Any], + local_size: Optional[int] = None, +) -> None: + with MultiProcessContext(rank, world_size, backend, local_size) as ctx: + kjt_input = kjt_input_per_rank[rank].to(ctx.device) + + train_model = SparseArch( + tables=tables, + device=torch.device("cuda"), + input_hash_size=0, + return_remapped=True, + buckets=num_buckets, + ) + train_sharding_plan = construct_module_sharding_plan( + train_model._mc_ec, + per_param_sharding={"table_0": row_wise(), "table_1": row_wise()}, + local_size=local_size, + world_size=world_size, + device_type="cuda", + sharder=sharder, + ) + print(f"train_sharding_plan: {train_sharding_plan}") + sharded_train_model = _shard_modules( + module=copy.deepcopy(train_model), + plan=ShardingPlan({"_mc_ec": train_sharding_plan}), + env=ShardingEnv.from_process_group(none_throws(ctx.pg)), + sharders=[sharder], + device=ctx.device, + ) + # train + sharded_train_model(kjt_input.to(ctx.device)) + + for ( + key, + value, + ) in ( + # pyre-ignore + sharded_train_model._mc_ec._managed_collision_collection._managed_collision_modules.state_dict().items() + ): + return_dict[f"mc_{key}_{rank}"] = value.cpu() + for ( + key, + value, + # pyre-ignore + ) in sharded_train_model._mc_ec._embedding_collection.state_dict().items(): + tensors = [] + for i in range(len(value.local_shards())): + tensors.append(value.local_shards()[i].tensor.cpu()) + return_dict[f"ec_{key}_{rank}"] = torch.cat(tensors, dim=0) diff --git a/torchrec/modules/hash_mc_evictions.py b/torchrec/modules/hash_mc_evictions.py new file mode 100644 index 000000000..c5875bf8d --- /dev/null +++ b/torchrec/modules/hash_mc_evictions.py @@ -0,0 +1,257 @@ +#!/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 time +from dataclasses import dataclass +from enum import Enum, unique +from typing import List, Optional, Tuple + +import torch +from pyre_extensions import none_throws + +from torchrec.sparse.jagged_tensor import JaggedTensor + +logger: logging.Logger = logging.getLogger(__name__) + + +@unique +class HashZchEvictionPolicyName(Enum): + # eviction based on the time the ID is last seen during training, + # and a single TTL + SINGLE_TTL_EVICTION = "SINGLE_TTL_EVICTION" + # eviction based on the time the ID is last seen during training, + # and per-feature TTLs + PER_FEATURE_TTL_EVICTION = "PER_FEATURE_TTL_EVICTION" + # eviction based on least recently seen ID within the probe range + LRU_EVICTION = "LRU_EVICTION" + + +@torch.jit.script +@dataclass +class HashZchEvictionConfig: + features: List[str] + single_ttl: Optional[int] = None + per_feature_ttl: Optional[List[int]] = None + + +@torch.fx.wrap +def get_kernel_from_policy( + policy_name: Optional[HashZchEvictionPolicyName], +) -> int: + return ( + 1 + if policy_name is not None + and policy_name == HashZchEvictionPolicyName.LRU_EVICTION + else 0 + ) + + +class HashZchEvictionScorer: + def __init__(self, config: HashZchEvictionConfig) -> None: + self._config: HashZchEvictionConfig = config + + def gen_score(self, feature: JaggedTensor, device: torch.device) -> torch.Tensor: + return torch.empty(0, device=device) + + def gen_threshold(self) -> int: + return -1 + + +class HashZchSingleTtlScorer(HashZchEvictionScorer): + def gen_score(self, feature: JaggedTensor, device: torch.device) -> torch.Tensor: + assert ( + self._config.single_ttl is not None and self._config.single_ttl > 0 + ), "To use scorer HashZchSingleTtlScorer, a positive single_ttl is required." + + return torch.full_like( + feature.values(), + # pyre-ignore [58] + self._config.single_ttl + int(time.time() / 3600), + dtype=torch.int32, + device=device, + ) + + def gen_threshold(self) -> int: + return int(time.time() / 3600) + + +class HashZchPerFeatureTtlScorer(HashZchEvictionScorer): + def __init__(self, config: HashZchEvictionConfig) -> None: + super().__init__(config) + + assert self._config.per_feature_ttl is not None and len( + self._config.features + ) == len( + # pyre-ignore [6] + self._config.per_feature_ttl + ), "To use scorer HashZchPerFeatureTtlScorer, a 1:1 mapping between features and per_feature_ttl is required." + + self._per_feature_ttl = torch.IntTensor(self._config.per_feature_ttl) + + def gen_score(self, feature: JaggedTensor, device: torch.device) -> torch.Tensor: + feature_split = feature.weights() + assert feature_split.size(0) == self._per_feature_ttl.size(0) + + scores = self._per_feature_ttl.repeat_interleave(feature_split) + int( + time.time() / 3600 + ) + + return scores.to(device=device) + + def gen_threshold(self) -> int: + return int(time.time() / 3600) + + +@torch.fx.wrap +def get_eviction_scorer( + policy_name: str, config: HashZchEvictionConfig +) -> HashZchEvictionScorer: + if policy_name == HashZchEvictionPolicyName.SINGLE_TTL_EVICTION: + return HashZchSingleTtlScorer(config) + elif policy_name == HashZchEvictionPolicyName.PER_FEATURE_TTL_EVICTION: + return HashZchPerFeatureTtlScorer(config) + elif policy_name == HashZchEvictionPolicyName.LRU_EVICTION: + return HashZchSingleTtlScorer(config) + else: + return HashZchEvictionScorer(config) + + +class HashZchThresholdEvictionModule(torch.nn.Module): + """ + This module manages the computation of eviction score for input IDs. Based on the selected + eviction policy, a scorer is initiated to generate a score for each ID. The kernel + will use this score to make eviction decisions. + + Args: + policy_name: an enum value that indicates the eviction policy to use. + config: a config that contains information needed to run the eviction policy. + + Example:: + module = HashZchThresholdEvictionModule(...) + score = module(feature) + """ + + _eviction_scorer: HashZchEvictionScorer + + def __init__( + self, + policy_name: HashZchEvictionPolicyName, + config: HashZchEvictionConfig, + ) -> None: + super().__init__() + + self._policy_name: HashZchEvictionPolicyName = policy_name + self._config: HashZchEvictionConfig = config + self._eviction_scorer = get_eviction_scorer( + policy_name=self._policy_name, + config=self._config, + ) + + logger.info( + f"HashZchThresholdEvictionModule: {self._policy_name=}, {self._config=}" + ) + + def forward( + self, feature: JaggedTensor, device: torch.device + ) -> Tuple[torch.Tensor, int]: + """ + Args: + feature: a jagged tensor that contains the input IDs, and their lengths and + weights (feature split). + device: device of the tensor. + + Returns: + a tensor that contains the eviction score for each ID, plus an eviction threshold. + """ + return ( + self._eviction_scorer.gen_score(feature, device), + self._eviction_scorer.gen_threshold(), + ) + + +class HashZchOptEvictionModule(torch.nn.Module): + """ + This module manages the eviction of IDs from the ZCH table based on the selected eviction policy. + Args: + policy_name: an enum value that indicates the eviction policy to use. + Example: + module = HashZchOptEvictionModule(policy_name=HashZchEvictionPolicyName.LRU_EVICTION) + """ + + def __init__( + self, + policy_name: HashZchEvictionPolicyName, + ) -> None: + super().__init__() + + self._policy_name: HashZchEvictionPolicyName = policy_name + + def forward(self, feature: JaggedTensor, device: torch.device) -> Tuple[None, int]: + """ + Does not apply to this Eviction Policy. Returns None and -1. + Args: + feature: No op + Returns: + None, -1 + """ + return None, -1 + + +@torch.fx.wrap +def get_eviction_module( + policy_name: HashZchEvictionPolicyName, config: Optional[HashZchEvictionConfig] +) -> torch.nn.Module: + if policy_name in ( + HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + HashZchEvictionPolicyName.PER_FEATURE_TTL_EVICTION, + HashZchEvictionPolicyName.LRU_EVICTION, + ): + return HashZchThresholdEvictionModule(policy_name, none_throws(config)) + else: + return HashZchOptEvictionModule(policy_name) + + +class HashZchEvictionModule(torch.nn.Module): + """ + This module manages the eviction of IDs from the ZCH table based on the selected eviction policy. + Args: + policy_name: an enum value that indicates the eviction policy to use. + device: device of the tensor. + config: an optional config required if threshold based eviction is selected. + Example: + module = HashZchEvictionModule(policy_name=HashZchEvictionPolicyName.LRU_EVICTION) + """ + + def __init__( + self, + policy_name: HashZchEvictionPolicyName, + device: torch.device, + config: Optional[HashZchEvictionConfig], + ) -> None: + super().__init__() + + self._policy_name: HashZchEvictionPolicyName = policy_name + self._device: torch.device = device + self._eviction_module: torch.nn.Module = get_eviction_module( + self._policy_name, config + ) + + logger.info(f"HashZchEvictionModule: {self._policy_name=}, {self._device=}") + + def forward(self, feature: JaggedTensor) -> Tuple[Optional[torch.Tensor], int]: + """ + Args: + feature: a jagged tensor that contains the input IDs, and their lengths and + weights (feature split). + + Returns: + For threshold eviction, a tensor that contains the eviction score for each ID, plus an eviction threshold. Otherwise None and -1. + """ + return self._eviction_module(feature, self._device) diff --git a/torchrec/modules/hash_mc_metrics.py b/torchrec/modules/hash_mc_metrics.py new file mode 100644 index 000000000..714cf8c2a --- /dev/null +++ b/torchrec/modules/hash_mc_metrics.py @@ -0,0 +1,200 @@ +#!/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 time +from typing import Optional + +import torch + +from torchrec.modules.hash_mc_evictions import HashZchEvictionConfig + + +class ScalarLogger(torch.nn.Module): + """ + A logger to report various metrics related to multi-probe ZCH. + + Args: + name: name of the embedding table. + zch_size: size of the sharded embedding table. + frequency: frequency of reporting metrics. + start_bucket: start bucket of the rank. + + + Example:: + logger = ScalarLogger(...) + logger(run_type, identities) + """ + + STEPS_BUFFER: str = "_scalar_logger_steps" + SECONDS_IN_HOUR: int = 3600 + MAX_HOURS: int = 2**31 - 1 + + def __init__( + self, + name: str, + zch_size: int, + frequency: int, + start_bucket: int, + log_file_path: str = "", + ) -> None: + super().__init__() + + self.register_buffer( + ScalarLogger.STEPS_BUFFER, + torch.tensor(1, dtype=torch.int64), + persistent=False, + ) + + self._name: str = name + self._zch_size: int = zch_size + self._frequency: int = frequency + self._start_bucket: int = start_bucket + + self._dtype_checked: bool = False + self._total_cnt: int = 0 + self._hit_cnt: int = 0 + self._insert_cnt: int = 0 + self._collision_cnt: int = 0 + self._eviction_cnt: int = 0 + self._opt_in_cnt: int = 0 + self._sum_eviction_age: float = 0.0 + + self.logger: logging.Logger = logging.getLogger() + if ( + log_file_path != "" + ): # if a log file path is provided, create a file handler to output logs to the file + file_handler = logging.FileHandler( + log_file_path, mode="w" + ) # initialize file handler + self.logger.addHandler(file_handler) # add file handler to logger + + def should_report(self) -> bool: + # We only need to report metrics from rank0 (start_bucket = 0) + + return ( + self._start_bucket == 0 + and self._total_cnt > 0 + and + # pyre-fixme[29]: `Union[(self: TensorBase, other: Any) -> Tensor, Tensor, + # Module]` is not a function. + self._scalar_logger_steps % self._frequency == 0 + ) + + def update( + self, + identities_0: torch.Tensor, + identities_1: torch.Tensor, + values: torch.Tensor, + remapped_ids: torch.Tensor, + evicted_emb_indices: Optional[torch.Tensor], + metadata: Optional[torch.Tensor], + num_reserved_slots: int, + eviction_config: Optional[HashZchEvictionConfig] = None, + ) -> None: + if not self._dtype_checked: + assert ( + identities_0.dtype == values.dtype + ), "identity type and feature type must match for meaningful metrics collection." + self._dtype_checked = True + + remapped_identities_0 = torch.index_select(identities_0, 0, remapped_ids)[:, 0] + remapped_identities_1 = torch.index_select(identities_1, 0, remapped_ids)[:, 0] + empty_slot_cnt_before_process = remapped_identities_0 == -1 + empty_slot_cnt_after_process = remapped_identities_1 == -1 + insert_cnt = int(torch.sum(empty_slot_cnt_before_process).item()) - int( + torch.sum(empty_slot_cnt_after_process).item() + ) + + self._insert_cnt += insert_cnt + self._total_cnt += values.numel() + hits = torch.eq(remapped_identities_0, values) + hit_cnt = int(torch.sum(hits).item()) + self._hit_cnt += hit_cnt + self._collision_cnt += values.numel() - hit_cnt - insert_cnt + + opt_in_range = self._zch_size - num_reserved_slots + opt_in_ids = torch.lt(remapped_ids, opt_in_range) + self._opt_in_cnt += int(torch.sum(opt_in_ids).item()) + + if evicted_emb_indices is not None and evicted_emb_indices.numel() > 0: + deduped_evicted_indices = torch.unique(evicted_emb_indices) + self._eviction_cnt += deduped_evicted_indices.numel() + + assert ( + metadata is not None + ), "metadata cannot be None when evicted_emb_indices has values" + now_c = int(time.time()) + cur_hour = now_c / ScalarLogger.SECONDS_IN_HOUR % ScalarLogger.MAX_HOURS + if eviction_config is not None and eviction_config.single_ttl is not None: + self._sum_eviction_age += int( + torch.sum( + cur_hour + + eviction_config.single_ttl + - metadata[deduped_evicted_indices, 0] + ).item() + ) + + def forward( + self, + run_type: str, + identities: torch.Tensor, + ) -> None: + """ + Args: + run_type: type of the run (train, eval, etc). + identities: the identities tensor for metrics computation. + + Returns: + None + """ + + if self.should_report(): + hit_rate = round(self._hit_cnt / self._total_cnt, 3) + insert_rate = round(self._insert_cnt / self._total_cnt, 3) + collision_rate = round(self._collision_cnt / self._total_cnt, 3) + eviction_rate = round(self._eviction_cnt / self._total_cnt, 3) + total_unused_slots = int(torch.sum(identities[:, 0] == -1).item()) + table_usage_ratio = round( + (self._zch_size - total_unused_slots) / self._zch_size, 3 + ) + opt_in_rate = ( + round(self._opt_in_cnt / self._total_cnt, 3) + if self._total_cnt > 0 + else 0 + ) + avg_eviction_age = ( + round(self._sum_eviction_age / self._eviction_cnt, 3) + if self._eviction_cnt > 0 + else 0 + ) + + # log the metrics to console (if no log file path is provided) or to the file (if a log file path is provided) + self.logger.info( + f"{self._name=}, {run_type=}, " + f"{self._total_cnt=}, {self._hit_cnt=}, {hit_rate=}, " + f"{self._insert_cnt=}, {insert_rate=}, " + f"{self._collision_cnt=}, {collision_rate=}, " + f"{self._eviction_cnt=}, {eviction_rate=}, {avg_eviction_age=}, " + f"{self._opt_in_cnt=}, {opt_in_rate=}, " + f"{total_unused_slots=}, {table_usage_ratio=}" + ) + + # reset the counter after reporting + self._total_cnt = 0 + self._hit_cnt = 0 + self._insert_cnt = 0 + self._collision_cnt = 0 + self._eviction_cnt = 0 + self._opt_in_cnt = 0 + self._sum_eviction_age = 0.0 + + # pyre-ignore[16]: `ScalarLogger` has no attribute `_scalar_logger_steps`. + # pyre-ignore[29]: `Union[(self: TensorBase, other: Any) -> Tensor, Tensor, Module]` is not a function. + self._scalar_logger_steps += 1 diff --git a/torchrec/modules/hash_mc_modules.py b/torchrec/modules/hash_mc_modules.py new file mode 100644 index 000000000..fe5a0ce19 --- /dev/null +++ b/torchrec/modules/hash_mc_modules.py @@ -0,0 +1,580 @@ +#!/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 math +from typing import Any, Dict, Iterator, List, Optional, Tuple + +import fbgemm_gpu # @manual=//deeplearning/fbgemm/fbgemm_gpu:fbgemm_gpu + +import torch + +from torchrec.modules.hash_mc_evictions import ( + get_kernel_from_policy, + HashZchEvictionConfig, + HashZchEvictionModule, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_metrics import ScalarLogger +from torchrec.modules.mc_modules import ManagedCollisionModule +from torchrec.sparse.jagged_tensor import JaggedTensor + +logger: logging.Logger = logging.getLogger(__name__) + + +@torch.fx.wrap +def _tensor_may_to_device( + src: torch.Tensor, + device: Optional[torch.device] = None, +) -> Tuple[torch.Tensor, torch.device]: + src_device: torch.device = src.device + if device is None: + return (src, src_device) + + if device.type != "meta" and src_device != device: + return (src.to(device), src_device) + return (src, src_device) + + +class TrainInputMapper(torch.nn.Module): + """ + Module used to generate sizes and offsets information corresponding to + the train ranks for inference inputs. This is due to we currently merge + all identity tensors that are row-wise sharded across training ranks at + inference time. So we need to map the inputs to the chunk of identities + that the input would go at training time to generate appropriate indices. + + Args: + input_hash_size: the max size of input IDs + total_num_buckets: the total number of buckets across all ranks at training time + size_per_rank: the size of the identity tensor/embedding size per rank + train_rank_offsets: the offset of the embedding table indices per rank + inference_dispatch_div_train_world_size: the flag to control whether to divide input by + world_size https://fburl.com/code/c9x98073 + name: the name of the embedding table + + Example:: + mapper = TrainInputMapper(...) + mapper(values, output_offset) + """ + + def __init__( + self, + input_hash_size: int, + total_num_buckets: int, + size_per_rank: torch.Tensor, + train_rank_offsets: torch.Tensor, + inference_dispatch_div_train_world_size: bool = False, + name: Optional[str] = None, + ) -> None: + super().__init__() + + self._input_hash_size = input_hash_size + assert total_num_buckets > 0, f"{total_num_buckets=} must be positive" + self._buckets = total_num_buckets + self._inference_dispatch_div_train_world_size = ( + inference_dispatch_div_train_world_size + ) + self._name = name + self.register_buffer( + "_zch_size_per_training_rank", size_per_rank, persistent=False + ) + self.register_buffer( + "_train_rank_offsets", train_rank_offsets, persistent=False + ) + logger.info( + f"TrainInputMapper: {self._name=}, {self._input_hash_size=}, {self._zch_size_per_training_rank=}, " + f"{self._train_rank_offsets=}, {self._inference_dispatch_div_train_world_size=}" + ) + + # TODO: make a kernel + def _get_values_sizes_offsets( + self, x: torch.Tensor, output_offset: Optional[torch.Tensor] + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[torch.Tensor]]: + zch_size_per_training_rank, _ = _tensor_may_to_device( + self._zch_size_per_training_rank, x.device + ) + train_rank_offsets, _ = _tensor_may_to_device( + self._train_rank_offsets, x.device + ) + + # NOTE: This assumption has to be the same as TorchRec input_dist logic + # https://fburl.com/code/c9x98073. Do not use torch.where() for performance. + if self._input_hash_size == 0: + train_ranks = x % self._buckets + if self._inference_dispatch_div_train_world_size: + x = x // self._buckets + else: + blk_size = (self._input_hash_size // self._buckets) + ( + 0 if self._input_hash_size % self._buckets == 0 else 1 + ) + train_ranks = x // blk_size + if self._inference_dispatch_div_train_world_size: + x = x % blk_size + + local_sizes = zch_size_per_training_rank.index_select( + dim=0, index=train_ranks + ) # This line causes error where zch_size_per_training_rank = tensor([25000, 25000, 25000, 25000], device='cuda:1') and train_ranks = tensor([291, 34, 15], device='cuda:1'), leading to index error: index out of range + offsets = train_rank_offsets.index_select(dim=0, index=train_ranks) + if output_offset is not None: + offsets -= output_offset + + return (x, local_sizes, offsets) + + def forward( + self, + values: torch.Tensor, + output_offset: Optional[torch.Tensor] = None, + ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[torch.Tensor]]: + """ + Args: + values: ID values to compute bucket assignment and offset. + output_offset: global offset of the start bucket per rank, used to compute bucket offset within the rank. + + Returns: + A tuple of three tensors: + - values: transformed ID values, different from input value only if inference_dispatch_div_train_world_size is True. + - local_sizes: bucket sizes of the input values. + - offsets: in-rank bucket offsets of the input values. + """ + + values, local_sizes, offsets = self._get_values_sizes_offsets( + values, output_offset + ) + return (values, local_sizes, offsets) + + +@torch.fx.wrap +def _get_device(hash_zch_identities: torch.Tensor) -> torch.device: + return hash_zch_identities.device + + +class HashZchManagedCollisionModule(ManagedCollisionModule): + """ + Module to manage multi-probe ZCH (MPZCH), including lookup (remapping), eviction, metrics collection, and required auxiliary tensors. + + Args: + zch_size: local size of the embedding table + device: the compute device + total_num_buckets: logical shard within each rank for resharding purpose, note that + 1) zch_size must be a multiple of total_num_buckets, and 2) total_num_buckets must be a multiple of world size + max_probe: the number of times MPZCH kernel attempts to run linear search for lookup or insertion + input_hash_size: the max size of input IDs (default to 0) + output_segments: the index range of each bucket, which is computed before sharding and typically not provided by user + is_inference: the flag to indicate if the module is used in inference as opposed to train or eval + name: the name of the embedding table + tb_logging_frequency: the frequency of emitting metrics to TensorBoard, measured by the number of batches + eviction_policy_name: the specific policy to be used for eviction operations + eviction_config: the config associated with the selected eviction policy + inference_dispatch_div_train_world_size: the flag to control whether to divide input by + world_size https://fburl.com/code/c9x98073 + start_bucket: start bucket of the current rank, typically not provided by user + end_bucket: end bucket of the current rank, typically not provided by user + opt_in_prob: the probability of an ID to be opted in from a statistical aspect + percent_reserved_slots: percentage of slots to be reserved when opt-in is enabled, the value must be in [0, 100) + + Example:: + module = HashZchManagedCollisionModule(...) + module(features) + """ + + _evicted_indices: List[torch.Tensor] + + IDENTITY_BUFFER: str = "_hash_zch_identities" + METADATA_BUFFER: str = "_hash_zch_metadata" + + def __init__( + self, + zch_size: int, + device: torch.device, + total_num_buckets: int, + max_probe: int = 128, + input_hash_size: int = 0, + output_segments: Optional[List[int]] = None, + is_inference: bool = False, + name: Optional[str] = None, + tb_logging_frequency: int = 0, + eviction_policy_name: Optional[HashZchEvictionPolicyName] = None, + eviction_config: Optional[HashZchEvictionConfig] = None, + inference_dispatch_div_train_world_size: bool = False, + start_bucket: int = 0, + end_bucket: Optional[int] = None, + opt_in_prob: int = -1, + percent_reserved_slots: float = 0, + ) -> None: + if output_segments is None: + assert ( + zch_size % total_num_buckets == 0 + ), f"please pass output segments if not uniform buckets {zch_size=}, {total_num_buckets=}" + output_segments = [ + (zch_size // total_num_buckets) * bucket + for bucket in range(total_num_buckets + 1) + ] + + super().__init__( + device=device, + output_segments=output_segments, + skip_state_validation=True, # avoid peristent buffers for TGIF Puslishing + ) + + self._zch_size: int = zch_size + self._output_segments: List[int] = output_segments + self._start_bucket: int = start_bucket + self._end_bucket: int = ( + end_bucket if end_bucket is not None else total_num_buckets + ) + self._output_global_offset_tensor: Optional[torch.Tensor] = None + if output_segments[start_bucket] > 0: + self._output_global_offset_tensor = torch.tensor( + [output_segments[start_bucket]], + dtype=torch.int64, + device=device if device.type != "meta" else torch.device("cpu"), + ) + + self._device: torch.device = device + self._input_hash_size: int = input_hash_size + self._is_inference: bool = is_inference + self._name: Optional[str] = name + self._tb_logging_frequency: int = tb_logging_frequency + self._scalar_logger: Optional[ScalarLogger] = None + self._eviction_policy_name: Optional[HashZchEvictionPolicyName] = ( + eviction_policy_name + ) + self._eviction_config: Optional[HashZchEvictionConfig] = eviction_config + self._eviction_module: Optional[HashZchEvictionModule] = ( + HashZchEvictionModule( + policy_name=self._eviction_policy_name, + device=self._device, + config=self._eviction_config, + ) + if self._eviction_policy_name is not None and self.training + else None + ) + self._opt_in_prob: int = opt_in_prob + assert ( + percent_reserved_slots >= 0 and percent_reserved_slots < 100 + ), "percent_reserved_slots must be in [0, 100)" + self._percent_reserved_slots: float = percent_reserved_slots + if self._opt_in_prob > 0: + assert ( + self._percent_reserved_slots > 0 + ), "percent_reserved_slots must be positive when opt_in_prob is positive" + assert ( + self._eviction_policy_name is None + or self._eviction_policy_name != HashZchEvictionPolicyName.LRU_EVICTION + ), "LRU eviction is not compatible with opt-in at this time" + + if torch.jit.is_scripting() or self._is_inference or self._name is None: + self._tb_logging_frequency = 0 + + if self._tb_logging_frequency > 0 and self._device.type != "meta": + assert self._name is not None + self._scalar_logger = ScalarLogger( + name=self._name, + zch_size=self._zch_size, + frequency=self._tb_logging_frequency, + start_bucket=self._start_bucket, + ) + else: + logger.info( + f"ScalarLogger is disabled because {self._tb_logging_frequency=} and {self._device.type=}" + ) + + identities, metadata = torch.ops.fbgemm.create_zch_buffer( + size=self._zch_size, + support_evict=self._eviction_module is not None, + device=self._device, + long_type=True, # deprecated, always True + ) + + self._hash_zch_identities = torch.nn.Parameter(identities, requires_grad=False) + self.register_buffer(HashZchManagedCollisionModule.METADATA_BUFFER, metadata) + + self._max_probe = max_probe + self._buckets = total_num_buckets + # Do not need to store in buffer since this is created and consumed + # at each step https://fburl.com/code/axzimmbx + self._evicted_indices = [] + + # do not pass device, so its initialized on default physical device ('meta' will result in silent failure) + size_per_rank = torch.diff( + torch.tensor(self._output_segments, dtype=torch.int64) + ) + + self.input_mapper: torch.nn.Module = TrainInputMapper( + input_hash_size=self._input_hash_size, + total_num_buckets=total_num_buckets, + size_per_rank=size_per_rank, + train_rank_offsets=torch.tensor( + torch.ops.fbgemm.asynchronous_exclusive_cumsum(size_per_rank) + ), + # be consistent with https://fburl.com/code/p4mj4mc1 + inference_dispatch_div_train_world_size=inference_dispatch_div_train_world_size, + name=self._name, + ) + + if self._is_inference is True: + self.reset_inference_mode() + + logger.info( + f"HashZchManagedCollisionModule: {self._name=}, {self.device=}, " + f"{self._zch_size=}, {self._input_hash_size=}, {self._max_probe=}, " + f"{self._is_inference=}, {self._tb_logging_frequency=}, " + f"{self._eviction_policy_name=}, {self._eviction_config=}, " + f"{self._buckets=}, {self._start_bucket=}, {self._end_bucket=}, " + f"{self._output_global_offset_tensor=}, {self._output_segments=}, " + f"{inference_dispatch_div_train_world_size=}, " + f"{self._opt_in_prob=}, {self._percent_reserved_slots=}" + ) + + @property + def device(self) -> torch.device: + return _get_device(self._hash_zch_identities) + + def buckets(self) -> int: + return self._buckets + + # TODO: This is hacky as we are using parameters to go through publishing. + # Can remove once working out buffer solution. + def named_buffers( + self, prefix: str = "", recurse: bool = True, remove_duplicate: bool = True + ) -> Iterator[Tuple[str, torch.Tensor]]: + yield from super().named_buffers(prefix, recurse, remove_duplicate) + key: str = HashZchManagedCollisionModule.IDENTITY_BUFFER + if prefix: + key = f"{prefix}.{key}" + yield (key, self._hash_zch_identities.data) + + def validate_state(self) -> None: + raise NotImplementedError() + + def reset_inference_mode( + self, + ) -> None: + logger.info("HashZchManagedCollisionModule resetting inference mode") + # not revertable + self.eval() + self._is_inference = True + self._hash_zch_metadata = None + self._evicted_indices = [] + self._eviction_policy_name = None + self._eviction_module = None + + def _load_state_dict_pre_hook( + module: "HashZchManagedCollisionModule", + state_dict: Dict[str, Any], + prefix: str, + *args: Any, + ) -> None: + logger.info("HashZchManagedCollisionModule loading state dict") + # We store the full identity in checkpoint and predictor, cut it at inference loading + if not self._is_inference: + return + if "_hash_zch_metadata" in state_dict: + del state_dict["_hash_zch_metadata"] + + self._register_load_state_dict_pre_hook( + _load_state_dict_pre_hook, with_module=True + ) + + def preprocess( + self, + features: Dict[str, JaggedTensor], + ) -> Dict[str, JaggedTensor]: + return features + + def evict(self) -> Optional[torch.Tensor]: + if len(self._evicted_indices) == 0: + return None + out = torch.unique(torch.cat(self._evicted_indices)) + self._evicted_indices = [] + return ( + out + self._output_global_offset_tensor + if self._output_global_offset_tensor + else out + ) + + def profile( + self, + features: Dict[str, JaggedTensor], + ) -> Dict[str, JaggedTensor]: + return features + + def get_reserved_slots_per_bucket(self) -> int: + if self._opt_in_prob == -1: + return -1 + + return math.floor( + self._zch_size + * self._percent_reserved_slots + / 100 + / (self._end_bucket - self._start_bucket) + ) + + def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: + metadata: Optional[torch.Tensor] = self._hash_zch_metadata + readonly: bool = False + if self._output_global_offset_tensor is not None: + self._output_global_offset_tensor, _ = _tensor_may_to_device( + self._output_global_offset_tensor, self.device + ) + if not self.training: + readonly = True + metadata = None + + # _evicted_indices will be reset in evict(): https://fburl.com/code/r3fxcs1y + assert len(self._evicted_indices) == 0 + + # `torch.no_grad()` Annotatin prevents torchscripting `JaggedTensor` for some reason... + with torch.no_grad(): + remapped_features: Dict[str, JaggedTensor] = {} + identities_0 = ( + self._hash_zch_identities.data.clone() + if self._tb_logging_frequency > 0 + else None + ) + + for name, feature in features.items(): + values = feature.values() + input_metadata, eviction_threshold = ( + self._eviction_module(feature) + if self._eviction_module is not None + else (None, -1) + ) + + opt_in_rands = ( + (torch.rand_like(values, dtype=torch.float) * 100).to(torch.int32) + if self._opt_in_prob != -1 and self.training + else None + ) + + values, orig_device = _tensor_may_to_device(values, self.device) + values, local_sizes, offsets = self.input_mapper( + values=values, + output_offset=self._output_global_offset_tensor, + ) + num_reserved_slots = self.get_reserved_slots_per_bucket() + remapped_ids, evictions = torch.ops.fbgemm.zero_collision_hash( + input=values, + identities=self._hash_zch_identities, + max_probe=self._max_probe, + circular_probe=True, + exp_hours=-1, # deprecated, always -1 + readonly=readonly, + local_sizes=local_sizes, + offsets=offsets, + metadata=metadata, + # Use self._is_inference to turn on writing to pinned + # CPU memory directly. But may not have perf benefit. + output_on_uvm=False, # self._is_inference, + disable_fallback=False, + _modulo_identity_DPRECATED=False, # deprecated, always False + input_metadata=input_metadata, + eviction_threshold=eviction_threshold, + eviction_policy=get_kernel_from_policy(self._eviction_policy_name), + opt_in_prob=self._opt_in_prob, + num_reserved_slots=num_reserved_slots, + opt_in_rands=opt_in_rands, + ) + + if self._scalar_logger is not None: + assert identities_0 is not None + self._scalar_logger.update( + identities_0=identities_0, + identities_1=self._hash_zch_identities, + values=values, + remapped_ids=remapped_ids, + evicted_emb_indices=evictions, + metadata=metadata, + num_reserved_slots=num_reserved_slots, + eviction_config=self._eviction_config, + ) + + output_global_offset_tensor = self._output_global_offset_tensor + if output_global_offset_tensor is not None: + remapped_ids = remapped_ids + output_global_offset_tensor + + _append_eviction_indice(self._evicted_indices, evictions) + remapped_ids, _ = _tensor_may_to_device(remapped_ids, orig_device) + + remapped_features[name] = JaggedTensor( + values=remapped_ids, + lengths=feature.lengths(), + offsets=feature.offsets(), + weights=feature.weights_or_none(), + ) + + if self._scalar_logger is not None: + self._scalar_logger( + run_type="train" if self.training else "eval", + identities=self._hash_zch_identities.data, + ) + + return remapped_features + + def forward( + self, + features: Dict[str, JaggedTensor], + ) -> Dict[str, JaggedTensor]: + return self.remap(features) + + def output_size(self) -> int: + return self._zch_size + + def input_size(self) -> int: + return self._input_hash_size + + def open_slots(self) -> torch.Tensor: + return torch.tensor([0]) + + def rebuild_with_output_id_range( + self, + output_id_range: Tuple[int, int], + output_segments: Optional[List[int]] = None, + device: Optional[torch.device] = None, + ) -> "HashZchManagedCollisionModule": + # rebuild should use existing output_segments instead of the input one and should not + # recalculate since the output segments are calculated based on the original embedding + # table size, total bucket number, which might not be available for the rebuild caller + try: + start_idx = self._output_segments.index(output_id_range[0]) + end_idx = self._output_segments.index(output_id_range[1]) + except ValueError: + raise RuntimeError( + f"Attempting to shard HashZchManagedCollisionModule, but rank {device} does not align with bucket boundaries;" + + f" please check kwarg total_num_buckets={self._buckets} is a multiple of world size." + ) + new_zch_size = output_id_range[1] - output_id_range[0] + + return self.__class__( + zch_size=new_zch_size, + device=device or self.device, + max_probe=self._max_probe, + total_num_buckets=self._buckets, + input_hash_size=self._input_hash_size, + is_inference=self._is_inference, + start_bucket=start_idx, + end_bucket=end_idx, + output_segments=self._output_segments, + name=self._name, + tb_logging_frequency=self._tb_logging_frequency, + eviction_policy_name=self._eviction_policy_name, + eviction_config=self._eviction_config, + opt_in_prob=self._opt_in_prob, + percent_reserved_slots=self._percent_reserved_slots, + ) + + +@torch.fx.wrap +def _append_eviction_indice( + evicted_indices: List[torch.Tensor], + evictions: Optional[torch.Tensor], +) -> None: + if evictions is not None and evictions.numel() > 0: + evicted_indices.append(evictions) diff --git a/torchrec/modules/tests/test_hash_mc_evictions.py b/torchrec/modules/tests/test_hash_mc_evictions.py new file mode 100644 index 000000000..e62b0d819 --- /dev/null +++ b/torchrec/modules/tests/test_hash_mc_evictions.py @@ -0,0 +1,72 @@ +#!/usr/bin/env python3 +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict + +import unittest +from unittest.mock import patch + +import torch +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchPerFeatureTtlScorer, + HashZchSingleTtlScorer, +) +from torchrec.sparse.jagged_tensor import JaggedTensor + + +class TestEvictionScorer(unittest.TestCase): + # pyre-ignore [56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "This test requires CUDA device", + ) + def test_single_ttl_scorer(self) -> None: + scorer = HashZchSingleTtlScorer( + config=HashZchEvictionConfig(features=["f1"], single_ttl=24) + ) + + jt = JaggedTensor( + values=torch.arange(0, 5, dtype=torch.int64), + lengths=torch.tensor([2, 2, 1], dtype=torch.int64), + ) + + with patch("time.time") as mock_time: + mock_time.return_value = 36000000 # hour 10000 + score = scorer.gen_score(jt, device=torch.device("cuda")) + self.assertTrue( + torch.equal( + score, + torch.tensor([10024, 10024, 10024, 10024, 10024], device="cuda"), + ), + f"{torch.unique(score)=}", + ) + + # pyre-ignore [56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "This test requires CUDA device", + ) + def test_per_feature_ttl_scorer(self) -> None: + scorer = HashZchPerFeatureTtlScorer( + config=HashZchEvictionConfig( + features=["f1", "f2"], per_feature_ttl=[24, 48] + ) + ) + + jt = JaggedTensor( + values=torch.arange(0, 5, dtype=torch.int64), + lengths=torch.tensor([2, 2, 1], dtype=torch.int64), + weights=torch.tensor([4, 1], dtype=torch.int64), + ) + + with patch("time.time") as mock_time: + mock_time.return_value = 36000000 # hour 10000 + score = scorer.gen_score(jt, device=torch.device("cuda")) + self.assertTrue( + torch.equal( + score, + torch.tensor([10024, 10024, 10024, 10024, 10048], device="cuda"), + ), + f"{torch.unique(score)=}", + ) diff --git a/torchrec/modules/tests/test_hash_mc_modules.py b/torchrec/modules/tests/test_hash_mc_modules.py new file mode 100644 index 000000000..113c05b5b --- /dev/null +++ b/torchrec/modules/tests/test_hash_mc_modules.py @@ -0,0 +1,650 @@ +#!/usr/bin/env python3 +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict + +import unittest +from typing import cast + +import torch +from hypothesis import given, settings, strategies as st +from pyre_extensions import none_throws +from torchrec.distributed.embedding_sharding import bucketize_kjt_before_all2all +from torchrec.modules.embedding_configs import EmbeddingConfig +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_modules import ( + ManagedCollisionCollection, + ManagedCollisionModule, +) +from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor + + +class TestMCH(unittest.TestCase): + # pyre-ignore[56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "Not enough GPUs, this test requires at least two GPUs", + ) + def test_zch_hash_inference(self) -> None: + # prepare + m1 = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("cuda"), + total_num_buckets=2, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=[], + single_ttl=10, + ), + ) + self.assertEqual(m1._hash_zch_identities.dtype, torch.int64) + in1 = { + "f": JaggedTensor( + values=torch.arange(0, 20, 2, dtype=torch.int64, device="cuda"), + lengths=torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + ), + } + o1 = m1(in1)["f"].values() + self.assertTrue( + torch.equal(torch.unique(o1), torch.arange(0, 10, device="cuda")), + f"{torch.unique(o1)=}", + ) + + in2 = { + "f": JaggedTensor( + values=torch.arange(1, 20, 2, dtype=torch.int64, device="cuda"), + lengths=torch.tensor([8, 2], dtype=torch.int64, device="cuda"), + ), + } + o2 = m1(in2)["f"].values() + self.assertTrue( + torch.equal(torch.unique(o2), torch.arange(10, 20, device="cuda")), + f"{torch.unique(o2)=}", + ) + + for device_str in ["cpu", "cuda"]: + # Inference + m_infer = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device(device_str), + total_num_buckets=2, + ) + + m_infer.reset_inference_mode() + m_infer.to(device_str) + + self.assertTrue( + torch.equal( + # pyre-fixme[6]: For 1st argument expected `Tensor` but got + # `Union[Tensor, Module]`. + none_throws(m_infer.input_mapper._zch_size_per_training_rank), + torch.tensor([10, 10], dtype=torch.int64, device=device_str), + ) + ) + self.assertTrue( + torch.equal( + # pyre-fixme[6]: For 1st argument expected `Tensor` but got + # `Union[Tensor, Module]`. + none_throws(m_infer.input_mapper._train_rank_offsets), + torch.tensor([0, 10], dtype=torch.int64, device=device_str), + ) + ) + + m_infer._hash_zch_identities = torch.nn.Parameter( + m1._hash_zch_identities[:, :1], + requires_grad=False, + ) + in12 = { + "f": JaggedTensor( + values=torch.arange(0, 20, dtype=torch.int64, device=device_str), + lengths=torch.tensor( + [4, 6, 8, 2], dtype=torch.int64, device=device_str + ), + ), + } + m_infer = torch.jit.script(m_infer) + o_infer = m_infer(in12)["f"].values() + o12 = torch.stack([o1, o2], dim=1).view(-1).to(device_str) + self.assertTrue(torch.equal(o_infer, o12), f"{o_infer=} vs {o12=}") + + m3 = HashZchManagedCollisionModule( + zch_size=10, + device=torch.device("cuda"), + total_num_buckets=2, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=[], + single_ttl=10, + ), + ) + self.assertEqual(m3._hash_zch_identities.dtype, torch.int64) + in3 = { + "f": JaggedTensor( + values=torch.arange(10, 20, dtype=torch.int64, device="cuda"), + lengths=torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + ), + } + o3 = m3(in3)["f"].values() + self.assertTrue( + torch.equal(torch.unique(o3), torch.arange(0, 10, device="cuda")), + f"{torch.unique(o3)=}", + ) + # validate that original ids are assigned to identities + self.assertTrue( + torch.equal( + torch.unique(m3._hash_zch_identities), + torch.arange(10, 20, device="cuda"), + ), + f"{torch.unique(m3._hash_zch_identities)=}", + ) + + # pyre-ignore[56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "This test requires CUDA device", + ) + def test_scriptability(self) -> None: + zch_size = 10 + mc_modules = { + "t1": cast( + ManagedCollisionModule, + HashZchManagedCollisionModule( + zch_size=zch_size, + device=torch.device("cpu"), + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=["feature"], + ), + total_num_buckets=2, + ), + ) + } + + embedding_configs = [ + EmbeddingConfig( + name="t1", + embedding_dim=8, + num_embeddings=zch_size, + feature_names=["f1", "f2"], + ), + ] + + mcc_ec = ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=embedding_configs, + ) + torch.jit.script(mcc_ec) + + # pyre-ignore[56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "This test requires CUDA device", + ) + def test_scriptability_lru(self) -> None: + zch_size = 10 + mc_modules = { + "t1": cast( + ManagedCollisionModule, + HashZchManagedCollisionModule( + zch_size=zch_size, + device=torch.device("cpu"), + total_num_buckets=2, + eviction_policy_name=HashZchEvictionPolicyName.LRU_EVICTION, + eviction_config=HashZchEvictionConfig( + features=["feature"], + single_ttl=12, + ), + ), + ) + } + + embedding_configs = [ + EmbeddingConfig( + name="t1", + embedding_dim=8, + num_embeddings=zch_size, + feature_names=["f1", "f2"], + ), + ] + + mcc_ec = ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=embedding_configs, + ) + torch.jit.script(mcc_ec) + + @unittest.skipIf( + torch.cuda.device_count() < 1, + "Not enough GPUs, this test requires at least one GPUs", + ) + # pyre-ignore [56] + @given(hash_size=st.sampled_from([0, 80]), keep_original_indices=st.booleans()) + @settings(max_examples=6, deadline=None) + def test_zch_hash_train_to_inf_block_bucketize( + self, hash_size: int, keep_original_indices: bool + ) -> None: + # rank 0 + world_size = 2 + kjt = KeyedJaggedTensor( + keys=["f"], + values=torch.cat( + [ + torch.arange(0, 20, 2, dtype=torch.int64, device="cuda"), + torch.arange(30, 60, 3, dtype=torch.int64, device="cuda"), + ] + ), + lengths=torch.cat( + [ + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + ] + ), + ) + block_sizes = torch.tensor( + [(size + world_size - 1) // world_size for size in [hash_size]], + dtype=torch.int64, + device="cuda", + ) + + bucketized_kjt, _ = bucketize_kjt_before_all2all( + kjt, + num_buckets=world_size, + block_sizes=block_sizes, + keep_original_indices=keep_original_indices, + ) + in1, in2 = bucketized_kjt.split([len(kjt.keys())] * world_size) + in1 = in1.to_dict() + in2 = in2.to_dict() + m0 = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("cuda"), + input_hash_size=hash_size, + total_num_buckets=2, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=[], + single_ttl=10, + ), + ) + m1 = m0.rebuild_with_output_id_range((0, 10)) + m2 = m0.rebuild_with_output_id_range((10, 20)) + + # simulate calls to each rank + o1 = m1(in1) + o2 = m2(in2) + + m0.reset_inference_mode() + full_zch_identities = torch.cat( + [ + m1.state_dict()["_hash_zch_identities"], + m2.state_dict()["_hash_zch_identities"], + ] + ) + state_dict = m0.state_dict() + state_dict["_hash_zch_identities"] = full_zch_identities + m0.load_state_dict(state_dict) + + # now pass in original kjt + inf_input = kjt.to_dict() + inf_output = m0(inf_input) + + torch.allclose( + inf_output["f"].values(), torch.cat([o1["f"].values(), o2["f"].values()]) + ) + + @unittest.skipIf( + torch.cuda.device_count() < 1, + "Not enough GPUs, this test requires at least one GPUs", + ) + # pyre-ignore [56] + @given(hash_size=st.sampled_from([0, 80])) + @settings(max_examples=5, deadline=None) + def test_zch_hash_train_rescales_two(self, hash_size: int) -> None: + keep_original_indices = False + # rank 0 + world_size = 2 + kjt = KeyedJaggedTensor( + keys=["f"], + values=torch.cat( + [ + torch.randint( + 0, + hash_size if hash_size > 0 else 1000, + (20,), + dtype=torch.int64, + device="cuda", + ), + ] + ), + lengths=torch.cat( + [ + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + ] + ), + ) + block_sizes = torch.tensor( + [(size + world_size - 1) // world_size for size in [hash_size]], + dtype=torch.int64, + device="cuda", + ) + sub_block_sizes = torch.tensor( + [(size + 2 - 1) // 2 for size in [block_sizes[0]]], + dtype=torch.int64, + device="cuda", + ) + bucketized_kjt, _ = bucketize_kjt_before_all2all( + kjt, + num_buckets=world_size, + block_sizes=block_sizes, + keep_original_indices=keep_original_indices, + ) + in1, in2 = bucketized_kjt.split([len(kjt.keys())] * world_size) + + bucketized_in1, _ = bucketize_kjt_before_all2all( + in1, + num_buckets=2, + block_sizes=sub_block_sizes, + keep_original_indices=keep_original_indices, + ) + bucketized_in2, _ = bucketize_kjt_before_all2all( + in2, + num_buckets=2, + block_sizes=sub_block_sizes, + keep_original_indices=keep_original_indices, + ) + in1_1, in1_2 = bucketized_in1.split([len(kjt.keys())] * 2) + in2_1, in2_2 = bucketized_in2.split([len(kjt.keys())] * 2) + + in1_1, in1_2 = in1_1.to_dict(), in1_2.to_dict() + in2_1, in2_2 = in2_1.to_dict(), in2_2.to_dict() + + m0 = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("cuda"), + input_hash_size=hash_size, + total_num_buckets=4, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=[], + single_ttl=10, + ), + ) + + m1_1 = m0.rebuild_with_output_id_range((0, 5)) + m1_2 = m0.rebuild_with_output_id_range((5, 10)) + m2_1 = m0.rebuild_with_output_id_range((10, 15)) + m2_2 = m0.rebuild_with_output_id_range((15, 20)) + + # simulate calls to each rank + o1_1 = m1_1(in1_1) + o1_2 = m1_2(in1_2) + o2_1 = m2_1(in2_1) + o2_2 = m2_2(in2_2) + + m0.reset_inference_mode() + + full_zch_identities = torch.cat( + [ + m1_1.state_dict()["_hash_zch_identities"], + m1_2.state_dict()["_hash_zch_identities"], + m2_1.state_dict()["_hash_zch_identities"], + m2_2.state_dict()["_hash_zch_identities"], + ] + ) + state_dict = m0.state_dict() + state_dict["_hash_zch_identities"] = full_zch_identities + m0.load_state_dict(state_dict) + + # now pass in original kjt + inf_input = kjt.to_dict() + inf_output = m0(inf_input) + torch.allclose( + inf_output["f"].values(), + torch.cat([x["f"].values() for x in [o1_1, o1_2, o2_1, o2_2]]), + ) + + @unittest.skipIf( + torch.cuda.device_count() < 1, + "Not enough GPUs, this test requires at least one GPUs", + ) + # pyre-ignore [56] + @given(hash_size=st.sampled_from([0, 80])) + @settings(max_examples=5, deadline=None) + def test_zch_hash_train_rescales_four(self, hash_size: int) -> None: + keep_original_indices = True + kjt = KeyedJaggedTensor( + keys=["f"], + values=torch.cat( + [ + torch.randint( + 0, + hash_size if hash_size > 0 else 1000, + (20,), + dtype=torch.int64, + device="cuda", + ), + ] + ), + lengths=torch.cat( + [ + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + torch.tensor([4, 6], dtype=torch.int64, device="cuda"), + ] + ), + ) + + # initialize mch with 8 buckets + m0 = HashZchManagedCollisionModule( + zch_size=40, + device=torch.device("cuda"), + input_hash_size=hash_size, + total_num_buckets=4, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=[], + single_ttl=10, + ), + ) + + # start with world_size = 4 + world_size = 4 + block_sizes = torch.tensor( + [(size + world_size - 1) // world_size for size in [hash_size]], + dtype=torch.int64, + device="cuda", + ) + + m1_1 = m0.rebuild_with_output_id_range((0, 10)) + m2_1 = m0.rebuild_with_output_id_range((10, 20)) + m3_1 = m0.rebuild_with_output_id_range((20, 30)) + m4_1 = m0.rebuild_with_output_id_range((30, 40)) + + # shard, now world size 2! + # start with world_size = 4 + if hash_size > 0: + world_size = 2 + block_sizes = torch.tensor( + [(size + world_size - 1) // world_size for size in [hash_size]], + dtype=torch.int64, + device="cuda", + ) + # simulate kjt call + bucketized_kjt, permute = bucketize_kjt_before_all2all( + kjt, + num_buckets=world_size, + block_sizes=block_sizes, + keep_original_indices=keep_original_indices, + output_permute=True, + ) + in1_2, in2_2 = bucketized_kjt.split([len(kjt.keys())] * world_size) + else: + bucketized_kjt, permute = bucketize_kjt_before_all2all( + kjt, + num_buckets=world_size, + block_sizes=block_sizes, + keep_original_indices=keep_original_indices, + output_permute=True, + ) + kjts = bucketized_kjt.split([len(kjt.keys())] * world_size) + # rebuild kjt + in1_2 = KeyedJaggedTensor( + keys=kjts[0].keys(), + values=torch.cat([kjts[0].values(), kjts[1].values()], dim=0), + lengths=torch.cat([kjts[0].lengths(), kjts[1].lengths()], dim=0), + ) + in2_2 = KeyedJaggedTensor( + keys=kjts[2].keys(), + values=torch.cat([kjts[2].values(), kjts[3].values()], dim=0), + lengths=torch.cat([kjts[2].lengths(), kjts[3].lengths()], dim=0), + ) + + m1_2 = m0.rebuild_with_output_id_range((0, 20)) + m2_2 = m0.rebuild_with_output_id_range((20, 40)) + m1_zch_identities = torch.cat( + [ + m1_1.state_dict()["_hash_zch_identities"], + m2_1.state_dict()["_hash_zch_identities"], + ] + ) + m1_zch_metadata = torch.cat( + [ + m1_1.state_dict()["_hash_zch_metadata"], + m2_1.state_dict()["_hash_zch_metadata"], + ] + ) + state_dict = m1_2.state_dict() + state_dict["_hash_zch_identities"] = m1_zch_identities + state_dict["_hash_zch_metadata"] = m1_zch_metadata + m1_2.load_state_dict(state_dict) + + m2_zch_identities = torch.cat( + [ + m3_1.state_dict()["_hash_zch_identities"], + m4_1.state_dict()["_hash_zch_identities"], + ] + ) + m2_zch_metadata = torch.cat( + [ + m3_1.state_dict()["_hash_zch_metadata"], + m4_1.state_dict()["_hash_zch_metadata"], + ] + ) + state_dict = m2_2.state_dict() + state_dict["_hash_zch_identities"] = m2_zch_identities + state_dict["_hash_zch_metadata"] = m2_zch_metadata + m2_2.load_state_dict(state_dict) + + _ = m1_2(in1_2.to_dict()) + _ = m2_2(in2_2.to_dict()) + + m0.reset_inference_mode() # just clears out training state + full_zch_identities = torch.cat( + [ + m1_2.state_dict()["_hash_zch_identities"], + m2_2.state_dict()["_hash_zch_identities"], + ] + ) + state_dict = m0.state_dict() + state_dict["_hash_zch_identities"] = full_zch_identities + m0.load_state_dict(state_dict) + + # now set all models to eval, and run kjt + m1_2.eval() + m2_2.eval() + assert m0.training is False + + inf_input = kjt.to_dict() + inf_output = m0(inf_input) + + o1_2 = m1_2(in1_2.to_dict()) + o2_2 = m2_2(in2_2.to_dict()) + self.assertTrue( + torch.allclose( + inf_output["f"].values(), + torch.index_select( + torch.cat([x["f"].values() for x in [o1_2, o2_2]]), + dim=0, + index=cast(torch.Tensor, permute), + ), + ) + ) + + # pyre-ignore[56] + @unittest.skipIf( + torch.cuda.device_count() < 1, + "This test requires CUDA device", + ) + def test_output_global_offset_tensor(self) -> None: + m = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("cpu"), + total_num_buckets=4, + ) + self.assertIsNone(m._output_global_offset_tensor) + + bucket2 = m.rebuild_with_output_id_range((5, 10)) + self.assertIsNotNone(bucket2._output_global_offset_tensor) + self.assertTrue( + # pyre-ignore [6] + torch.equal(bucket2._output_global_offset_tensor, torch.tensor([5])) + ) + self.assertEqual(bucket2._start_bucket, 1) + + m.reset_inference_mode() + bucket3 = m.rebuild_with_output_id_range((10, 15)) + self.assertIsNotNone(bucket3._output_global_offset_tensor) + self.assertTrue( + # pyre-ignore [6] + torch.equal(bucket3._output_global_offset_tensor, torch.tensor([10])) + ) + self.assertEqual(bucket3._start_bucket, 2) + self.assertEqual( + # pyre-ignore [16] + bucket3._output_global_offset_tensor.device.type, + "cpu", + ) + + remapped_indices = bucket3.remap( + { + "test": JaggedTensor( + values=torch.tensor( + [6, 10, 14, 18, 22], dtype=torch.int64, device="cpu" + ), + lengths=torch.tensor([5], dtype=torch.int64, device="cpu"), + ) + } + ) + self.assertTrue( + torch.allclose( + remapped_indices["test"].values(), torch.tensor([14, 10, 10, 11, 10]) + ) + ) + + gpu_zch = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("cuda"), + total_num_buckets=4, + ) + bucket4 = gpu_zch.rebuild_with_output_id_range((15, 20)) + self.assertIsNotNone(bucket4._output_global_offset_tensor) + self.assertTrue(bucket4._output_global_offset_tensor.device.type == "cuda") + self.assertEqual( + bucket4._output_global_offset_tensor, torch.tensor([15], device="cuda") + ) + + meta_zch = HashZchManagedCollisionModule( + zch_size=20, + device=torch.device("meta"), + total_num_buckets=4, + ) + meta_zch.reset_inference_mode() + self.assertIsNone(meta_zch._output_global_offset_tensor) + bucket5 = meta_zch.rebuild_with_output_id_range((15, 20)) + self.assertIsNotNone(bucket5._output_global_offset_tensor) + self.assertTrue(bucket5._output_global_offset_tensor.device.type == "cpu") + self.assertEqual(bucket5._output_global_offset_tensor, torch.tensor([15])) From eb5a752feafcae54aad6fd0dfb1a7033f0dd8cd8 Mon Sep 17 00:00:00 2001 From: Zhouyu Li Date: Mon, 16 Jun 2025 10:50:50 -0700 Subject: [PATCH 2/3] Create an example for MPZCH Summary: ### Major changes - Create a `mpzch` folder under the `torchrec/github/examples` folder - Implement a simple SparseArch module with a flag to switch between original and MPZCH managed collision modules - Profile the running time and QPS for model training(GPU)/inference(CPU) - Create a notebook tutorial for ZCH basics and the use of ZCH modules in TorchRec ### ToDos for OSS - When the internal torchrec MPZCH module is OSS - Remove the `BUCK` file - Replace all the `from torchrec.fb.modules` in `sparse_arch.py` to `from torchrec.modules` ### Potential improvement - Add hash collision counter - Show profiling results in the Readme file - Add multi-batch profiling Differential Revision: D75570684 Reviewed By: aporialiao --- examples/zch/Readme.md | 74 +++ examples/zch/__init__.py | 0 examples/zch/docs/mpzch_module_dataflow.png | Bin 0 -> 933087 bytes examples/zch/main.py | 131 +++++ examples/zch/sparse_arch.py | 137 +++++ .../zch/zero_collision_hash_tutorial.ipynb | 511 ++++++++++++++++++ 6 files changed, 853 insertions(+) create mode 100644 examples/zch/Readme.md create mode 100644 examples/zch/__init__.py create mode 100644 examples/zch/docs/mpzch_module_dataflow.png create mode 100644 examples/zch/main.py create mode 100644 examples/zch/sparse_arch.py create mode 100644 examples/zch/zero_collision_hash_tutorial.ipynb diff --git a/examples/zch/Readme.md b/examples/zch/Readme.md new file mode 100644 index 000000000..371034bb0 --- /dev/null +++ b/examples/zch/Readme.md @@ -0,0 +1,74 @@ +# Managed Collision Hash Example + +This example demonstrates the usage of managed collision hash feature in TorchRec, which is designed to efficiently handle hash collisions in embedding tables. We include two implementations of the feature: sorted managed collision Hash (MCH) and MPZCH (Multi-Probe Zero Collision Hash). + +## Folder Structure + +``` +managed_collision_hash/ +├── Readme.md # This documentation file +├── __init__.py # Python package marker +├── main.py # Main script to run the benchmark +└── sparse_arch.py # Implementation of the sparse architecture with managed collision +└── zero_collision_hash_tutorial.ipynb # Jupyter notebook for the motivation of zero collision hash and the use of zero collision hash modules in TorchRec +``` + +### Introduction of MPZCH + +Multi-probe Zero Collision Hash (MPZCH) is a technique that can be used to reduce the collision rate for embedding table lookups. For the concept of hash collision and why we need to manage the collision, please refer to the [zero collision hash tutorial](zero_collision_hash_tutorial.ipynb). + +A MPZCH module contains two essential tables: the identity table and the metadata table. +The identity table is used to record the mapping from input hash value to the remapped ID. The value in each identity table slot is an input hash value, and that hash value's remmaped ID is the index of the slot. +The metadata table share the same length as the identity table. The time when a hash value is inserted into a identity table slot is recorded in the same-indexed slot of the metadata table. + +Specifically, MPZCH include the following two steps: +1. **First Probe**: Check if there are available or evictable slots in its identity table. +2. **Second Probe**: Check if the slot for indexed with the input hash value is occupied. If not, directly insert the input hash value into that slot. Otherwise, perform a linear probe to find the next available slot. If all the slots are occupied, find the next evictable slot whose value has stayed in the table for a time longer than a threshold, and replace the expired hash value with the input one. + +The use of MPZCH module `HashZchManagedCollisionModule` are introduced with detailed comments in the [sparse_arch.py](sparse_arch.py) file. + +The module can be configured to use different eviction policies and parameters. + +The detailed function calls are shown in the diagram below +![MPZCH Module Data Flow](docs/mpzch_module_dataflow.png) + +#### Relationship among Important Parameters + +The `HashZchManagedCollisionModule` module has three important parameters for initialization +- `num_embeddings`: the number of embeddings in the embedding table +- `num_buckets`: the number of buckets in the hash table + +The `num_buckets` is used as the minimal sharding unit for the embedding table. Because we are doing linear probe in MPZCH, when resharding the embedding table, we want to avoid separate the remapped index of an input feature ID and its hash value to different ranks. So we make sure they are in the same bucket, and move the whole bucket during resharding. + +## Usage +We also prepare a profiling example of an Sparse Arch implemented with different ZCH techniques. +To run the profiling example with sorted ZCH: + +```bash +python main.py +``` + +To run the profiling example with MPZCH: + +```bash +python main.py --use_mpzch +``` + +You can also specify the `batch_size`, `num_iters`, and `num_embeddings_per_table`: +```bash +python main.py --use_mpzch --batch_size 8 --num_iters 100 --num_embeddings_per_table 1000 +``` + +The example allows you to compare the QPS of embedding operations with sorted ZCH and MPZCH. On our server with A100 GPU, the initial QPS benchmark results with `batch_size=8`, `num_iters=100`, and `num_embeddings_per_table=1000` is presented in the table below: + +| ZCH module | QPS | +| --- | --- | +| sorted ZCH | 1371.6942797862002 | +| MPZCH | 2750.4449443587414 | + +And with `batch_size=1024`, `num_iters=1000`, and `num_embeddings_per_table=1000` is + +| ZCH module | QPS | +| --- | --- | +| sorted ZCH | 263827.54955056956 | +| MPZCH | 551306.9687760604 | diff --git a/examples/zch/__init__.py b/examples/zch/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/examples/zch/docs/mpzch_module_dataflow.png b/examples/zch/docs/mpzch_module_dataflow.png new file mode 100644 index 0000000000000000000000000000000000000000..8ff4ba9e461d0bfba7929a99817de659dfba4733 GIT binary patch literal 933087 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
$ZcwEj)JV3CL)QN_ty1uQrD#m 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®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 z%0D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
    `ewWVm4UzA%t*RVDSQ=^E7GK z8C-P-3Sj@c7ZsV^G~JPX@%D2AA^NS!gHd4d8s)SuSHq$^o1I7CVnJKUc1XxZNS3A= zM+I;ahj$hMA)aH~lM<#-&z|KkdW61bdb4k8J_y+UQ~U(a&D)wDM6n)1^3Y8XjGjKX z8~KC(0xDE5jl+1L0W(E7GQ&>v%iV($ZliF@<)>%#SIiRX+nX!QW$M7a^_9K=SYSqN zo-#QTW!WyLO!yvg6D!ZXj2827=X<4;ipk89F4Mg+w=X{!zWf>rj%adU6!iWvT-}2< zRV1xHv~iqK)X65Fp)_g*o!0dDs6}Is#X2wwo%`&L7Zj&mlarH~uz2r7j(;7wwcB$e zgF->PMCbq9CI7K$(0?Mwc)q{w?Czn=#LMhdK8Fk8du?F~+6FJOxj1KC-qUIVjkk5dF65o>-4=pUUNnre|8~a#VC%-uFd3*ZS-zTr`smTAiEdyr%jUY7V=M2Zt+By^o;^N3MAfJS1h`45 z!AVfV_=`6vENAD>kXlmQTT&PGtlZ@S)Y{LjZA1*)x94dVTEFJG{Uz(PCe${Gs~Q)x zv?W4(8ztF^tE}b6$M;nnki38Q4Y}xc3#LwHeSY!0|9~cmW!O@>gwOU-CUuRby@`Bf z<$^&-4#S>LGA((!ZL4XIj*J zsX%lMf@ThpvSyWy5JE|LUx-z=Tnq6@8hL8l8ypG^6Q{?kH5rFV(~u|QBT=Hk0_6Ht zwSY0g&Q;s9EjeRy;tB3A_9(MY2`)!0P#hUAe*^5*7VCE~PtgP`13jv-AbReSq)vhdY>htScs!MbzzbyCWCkrL8+PIkwtLR<}oq5id( zxQPDe!le0v02)^}a_Zft_s@k8PfRlyG~*@i2w3a7Rbj%(O-|5;Pj=^}W_s2^^-%}j z{|pdacCnZVSV5eJ582?&7iph^(gk6gz-VUFafh})9(wwVJszMm9D!0@xro_b$8N0t zqU$h9CATab^8M)G^1X5ZxK&M#3eVlN?opZ)VA{*$brMam(BJ3;(L#JR!ko=Yb$jK3>!E(GB{b=lwG zIN2iID7>Hm5)36CZn)1UAuVP4I~=_>*Ijc^bRY*bbb4PkDu$cg65odwXSl@psq?(Z z1IMfkeda|MD1RJIBUJ}Xuc{rbRa1TkgJGL2T;xe^>zPcNvsD<>nEb84midU~J=&2}v9yeIW|A?foPMKmk=u>T(t%2D4 z8FYx|(--FAI$T3o;6-Ij1Ko*yxm;+j$N}oZwXPplN`#Tvp#`Qc8&I(K11_P788}Z#~o{Nk)NQ#Uk)oUYrll_b;+R4@)*|n z_2`9`pQcfySL>{w(}hrO4P-d}PeH@4{>%6j5V z14~*tu*xLyxZ`T&zKE5DsDmfASFj?E$orswAw2$Jz|pJ3-@(!*0p?PYGzAtt43yqUepH3WMczqP_VK7SDX&0nBSoZ( zOh~jUSAp+A2dPTu4re!49!H#qICV^Yt6wg-+`oI#H$iE}6x}m~<1z$r7^+p=ea%uA zfHNVdqM~xEe(P7Yn196@Gm4A=X&3qHSCm0vX(rzjeaYdmiyF!$=Px5Sur1S@$vG&0 zt4bJbELb`!Pw{xF?UTQ9T*Omi!`{8aN2=Z&Fa?A9*U+XsG_nV?V!$2jFzoH9!ZA5P z8h1d>{;o>0Roe+n)LOc=HmiMa{%3Fd=28=@EQlyP;fb^B?Ue@Sb+ zPV~rzbfY)H@6*I;XmnExwPy1ai6uquaXn#`-|a&8`RerOxuu2e*kjlM>j%%QZ3_A8 zUfEjq*y{YnAE&;)uGt)YG;imX)0~BwgNz}4*q?bOq_6>Dtpz+VN08a*-HWY6IPXcC zqnE9t<-T{&U!rSSE8z8PaaPXhXAv=|AvWzTdBn9 zc<1+tpiz@ERQ{tda^T>nPXHrL}{H}BN z^1#|mk47fg%s6$#!-3UOWM?c0^rPo|Id|rCki)suKGlY=gg<-p%tMe1c0S*tn&v#N zIP>Lv50GJ)ELf_wag$Np9o-7h{Dex(Y+}49VR#n=b3w=yg=`?i3i=F`n7N+De zlxD6Pxldr?7JR4*8o=i^CXX8jtgytFMAD?H-)u}soGtFB)BqWv9#MD5$;+=@rN$xc z#Z5o+2GK2Sz5~Y_2xo~iPd@MtrM)m$if+_1htImN+I3(BGXathwMxmln3=ycU6%0} zk8{e4-No9k_3}(-nmV20E1qZ2BD(ULmS%LoxFHbc{9QNZV2F4L+Lz}#YcP|b^a?E& zgA2IgV`;>Jl+dBn)u@Y%^*MplFF*J5zh1O!2ONy8SgBaF_>RM@3d=oB84Kw!<;%Dq zC@m)m->NEaxO?t8c5mYLmIwPTO*6w(zav6pr@y>P)3q!z#p(3@CQ>W1U>0_g-B8c? zfem`bos{)b7k_H6`u%Bh8(^|{#5PQj{<;f3m@|FBeY=Ff?%7iB5B@ZE=El8~4nmu)W9}LHdC5^u%J4XU`*Wa1uYkoz+-`#_L`Y`V2>r`lQwRnj9|n65Mze(`xoQR1{ADiU3e zSu+MUU_KvgKf|`1U_=?@k!#n;D4o9~2xLM8<|9<04oqD1OVidQrl-qhI%4OBfD%cy z+;ctknxg3DFMTYryh9G@QY4>+hH9$9&kH((lV>^*5^x`1^LqmCqH4ABcf+&-?&mwf zOZxCmxD$sj{Lcb$j~5Tzo(lUOr|h6Ef9gXTVl6L#QnVH?H$!asLp=Y4v#VJPU=HQ) z_p$Y0IKk{U3JRPqNIT?m22|$WcC$M2t;I{`HIDRL4 z?eTItI6)g@N$;o`NBkh# zv!}@wztDd`v}WA@%Kcx0)!0HC{UUJWAK~y=kp~!NC|H9wGC$JIbk7LDZqi%!q?m7L z6Ej``%LD_sh@zIb-VE~Jehca~B*CQ=ohUFNj^kEnX6se$X&vyG&XNCofwOEi;{2Tq zM4^0WwgN4-!N$7Fv=mS8Vp>k)yy0(r14t&C0T=h3gG<1k?pT|;C>n6OML*>-Z8-xZ z3)djWs~}#DG!-u1i)a6Yo46Z<4F0>XDwhiC}9)ibW_YXVopV#&GM@nd8lKlN%DFEc5 z%Xy&?FAmT3sHJ*Lx@-Y_mbeM51i}VY&gQ^__XG)RXWm`FVVBI`OR=4lD*-$T;rmO| zCZQG4%r$s1J7bnxr^T}j6-Zy1?#SK5??XS4c8(SU-*7K{$VwxsO?R1QZ^3ezFOlgx z`u$#72O)k+Cs85nG^PE-HJ+REU`YECc{A~>XF(ILqFA}K*k5g62%0Lixoq{GycuhW zl|Hlrc60222`FpKK13{J<_5qyn(oeGgcS7CkWmuQK} znl~GjKk|)B83hpR`L&Q$o%Ur}0LE&y3wEyE5pWMy>>fkIJn(9L*oi!S=!jb>ieIJe z#n`tm--{-0wqL%WL98Z2ql~us4A<@VA@KjyV(&woy9MmG4SU2r;QTuBF8aI&xb#8ggaaujnow3byH4s7JZNa@XPJwFf$fr73j-{^HRedNrUrQZaTjqW(W!${I>TtC{Cg90Iyem8P z5(iQvMe^v)bNDoYiO|WLdP9aYKK_{!KLtQr-H%)<-JhmQh6j>|)zV9RkA2U;wE7xK z8;45*aaQD^tU~U+v3o-_kdO#&3Hew}v1LxvcZ0|!4Pbdi%J0cDP`Y>EH=hS(ft#ZI z00$bcvT7H%r|AN<_sP_x%QP?2l>Bal zBsEd!6@Y}QEk)@tBV~uVNY6Afd*p$@ouyaE7Zx}w6Q-kAhwhOm5o4V4NZrI5fmpzU zuez+29Xs4USgRi(SY=ls3^6EBeAn16*}DrV8)KK>&JF>pda2)0dt07KjUo?e)HYN|3H50q&OlhmN?U&<3oQT+cyN zYS_-hu2Yc4-~)lQwMdcu?jq*ndEnlIUEkp!eZD!dcv~CeVq4D;XPbi>*{MQ%OJxxa zj9q+Dg8yV;U{7wD%5 z9a)XcHZB96DEaj0wKnz6>uYKxc^%ejn7Hq&&vcU?C1hv2i8|?skL@-7ZWs#M=@&FVW4^IgZKqI+e?oUbAuZd#3?Kf! zrnZj?CxAL8Eu?lPod2?d@L%uQ8$zqaKpNr2Hc#qJu<%n~ito!F|71 z7k)4-%J&*XG9=W1w@5fs-=G}J%9!}ZWAwYUCC2qqlTdac*S{futUUT)s>twm2}@%F zy&|54G&#`@C~!{#4!m<|NA;!lcp2d6RIsp1B~zq=7QBeey5y<9tEBDR$;FdF8@JCz z>mK3>{Q=hfB$$5g-)@0WU^?7f`7M6{%in8N%V4vC%-|zm=9`@Pf`ghxWHG^4gTjou z3#{gZzN0{)SAcToT`Yq_a6U#OR$NBx!kNcrY$< zX{|lQZm;d%R)a+U^1S}qXgm9H9u18}UrcU0JpJn?B{&T|mc*Ayo{u;-hYNOl!H4Z7 z;Iusomow&v8J9iU)H`XwSG%Re&z#k}tm79vr7foV+{^eWrF$40-5dxf( z5|(;m-}uiCG<`I?!ll0bx3)BaQ^xyXuQDFc;`w6%4OFoLpo)2lhwd+RSB_{B&pCIV z%Mtej)6I>IKs=nuwaBAZUIxo#*9<)BBhOz)24{kR1t!2~1$>p4Uex3mHwDAgxO)l^ z4q4=9`Q;PBX-2@^CJ=b-Y9{_DCmATKYRMS(!%yGApCj`XWx_)6<)25y6bKLqQo04j z#QdDcR>_Cw!eG}l0>a^R>+?LYVzI|ihs(UEdR?-@_^q$bt5c81E^)GK|5DpNpPf(t zN{Ib?sq3L~nU&>}z>citpRuG4|dC3K5W%eNw5fc z1sEzsG*LZy`?4M(<@SnC5YO<5k$m_e=17gV_=^uQrH9$`Y{Mi%T*&=5Wf2>I0N%&& zWdb^4zoxA*FAK`sVQEsd6U>(envRY2iSHEK_mHW}_e@&uoweij0j_Cv0aq89JzkFv zIc)?8FfGeoyPKE`ztLyh#brI4UuCDxzl#>n&O8*>`&d^)<7`rd?W6QzRK*oL&YT4w zt`};l*BYD@C29HL_J+9Svt-#RUZId!`-9)fjF$MQ7Z{aLMc*j^fRX$MjFjV{UZV}$ zTUnp*4g_i>4dGk5*RB~&x2!uskDCD9Q_+dT7IcBcS-v_`2P%)GJLH zx$Yx(*sRUPUGU+ry7$lP_z2#Bb%kj>3p*j#fA#`R6;2qg7KDJDsk)^gl7VAGRNy~d z%x(4iJ#WE1w2IQQC-J423D35VALJn6{??MJ!>-dQY0DILh?sD~g6xxz|BX9y4oNaY z`_Inza}&|Y-yt=MHVRGXbfqVFA8d9kVa~Wk+iq$ncf}L`eegG&?R7*f9&-!+jcfH! zQ;&$pWWk4|9nt-;QoLvg3f(Mf&h**>HUTGiYWx*ph&+i`f^nUX?VlGm&XI746xC#7~6H#`tJ|=7;+K$ z(AE0)NP0wtCepJG1*;&A`)bVD{aym7G)!tY%J}{L!cgw`L&{E?K{nz~=a|MLN{=V+ zTq^6hu}5#eVIli8XZ*E*E{t>g)Sf&v(R7Hn?R?izw#uqIqZ@U`&SD0z5M3<;k6r;p zAq*{%PXU8JKD=|LT+ap3%17%F)-X2a0_dMpvS+<<2CnvJkTrOHv5TAlM}-6lh8y*4{L`<@qXA(y&I0$xO-CW=}FBQ1qxt|_{}>*zitm*hCE zAbD;{Y`5k%K*34hz^L~x^!cv~QrrwRZ?u0sTVkrc6?;PtP}>J;ffuDMc<7Q?Q-t@u zmqKAnKlg5b<2P{a8u-x!Qh6o&N`xJ#HL2OZE92N?i8=6ca&Lx;P!?;-KvS00&Pha5 zB%Ts|eCq0PL9lq;U5|fiFAf|m@>SQE{(Ku<1Gfn#nuv3LoX5f*t^=D^c4d*J7eEE9 zw|jsb-1qLolLM`X$h7KSuX6-I^VLS|0R0J+V2tMMD606J68$y(p9C3d{$L#U!1ub@ zWkXnr9~hqxUJ@&WvWDv?(SG>i8u^D4{Ls2d{>a@!4O}${UpB+-Ob)j*yhQw1 zSd9`|$E%Q0&0kOP-~LPrsq-h&nYsVUqw+cio}k$x#B#t4qA%I8Kx~5zm@P?M^Td;z z@DkD4FmOe&6k-ui6%u2+r$xFan*H~a!(oik9nP`wG;d}AZ`I~&_kL{u5P_NiXV^{4 zPw)It#A5J1hYQB)$-S7+LQiNnV28gF|Gpoves&nJU0g2!yGul~Liiv`c94T!#}HhF z4sA-2)8ZT_{sn#tqo8LFMETMh1(s|WN}gnKbFEhvdogd@wjkfbKe6F*-Q5G%HO3QY zlQno2JJ+{hFi`XB$1v)dx)@?aa0%EE71n$r;q=kF>fh5p?)iOdgEd5z#4y zzdg5qf2v2&Lb&kwv)b=3{MY|^7Y&8lW<>JwKffwESZPGy7jIpN<->8`AA8c$)ZrYF zKeqB#8p@{TAX_5Fj}$*9`RzghzUko`V%JrOzq1TF?0K~!coUpNo)PBpL;@MQL_c{O zLKgo8`2&Polw3OkMq+#v+WuaXLpfl*2X9oeE^R>tFF9Nh6m(QS zdv&Xb-RNe*&$zw88ud>nqZuQty?=0GvU4{*GODH5@NpGU$)&$gJjWt8-09j}@0xzF zjIgEl94XopUKh~4$mG2G$C375fB%0jbNJ{h%Caf#2;V`s{@gt@p6|8}g0u5A@feh` z^o?M9uc^Wj_4%*_4L?rfa_~tZE<|{+mr31OJb@%$2CtKC4i=xBKL$aPZ^deFbf7AD!s65;N|_WVJz7B%h71x)EJX z3#HndjZnRpt6Pno^%db>FEwQMvE~uqqDa#Itd&Cxs|BgVKF=Pglkw;>tAwXxf!wau zyMJ>H@r%*+BUr{>+2sQ0(pLR%xL*qB5_KkNbUA;{=-mhDMTon(laxMiTe?9AJuoALM>c(zpp4na(U3I&MF^kEoUxNaM2m{aFu6 zJg;Ysrm5%nSE@4aJY0A+lkhcRzkI~r zU`j1hylWbgtQ+~tU@63u<_RFR?EGxW+$C~vj`Y_dLYCefhf1DKY}*BL!y&A+?xci^ixAPIP1j027lNFeerW-wKZLn8}!*BE}Vkt8~Cl7k<= z|J@fJLt&ga?^`Y6;Z*croafq6!{0((AZu{g#owRx@iG+tHi)6-AV? zm8{I{&55+EmQnUrB72WgD0}afY#G_d`dts>HR|>Le*XFW(d~B9$$6f~_>GRL=zS)XcY&hBJPN#(G_`V zb{GURTWuyPXmXb$&TDGrUD`Ymin^)CRdsTQ@TI3?mt9;Sqfa&T)GD)@;x-0xjUa_5 zrj!a5`{SPfzVWSBm?d;7#e4>3f1HZHl)JlJmTU;R`Png^t#Gawelhk{6g{}fkXvMq zA0E>G*h~;NkKz+>KkMC8d2(-4Dj53|+;tARU1|Eu{G=h-$~tNUTXps`l@v1(MqUZW z_k>9bEuP7z1hv>f$CxgjSH`zGU~`KGeh^b2Rxk-VEVh$fs{LkF{&J=Xi0aUZ)-v%{ zAjm;~AO+aNYyjbL6GaB*sbO7;`Q{o{Zx-Bm-oB{|cTkJoa7?+$Njg- z{D)?dpu=MRkHdOe0$aTiZ6Ae8AOCeGK!%YYgZD;fysp|z9T;zb{0vmP?`nxy|<)qjMdF))N5ks-`6F0B9}TL5{qIMIGn3-Wuh1+<<({hw(B>Jo_lPc5_sVgYL zoy^y0@15hu`GRo0c%To}3=p1YI}0AHjExv+JsK;!J~fDnV+cPji9Ygy?$U>(iyAg~nqpSu3Gf>@x75jrzfGUrA3ZzjVy>^P$N^(RLs%Xy>Sdr#BqBhI0hE@Zf*hdd2GM9MV(S1( zhLZ^3gGkzcigD+H8If#1 zl&0!(=W#jtbd;ZhB_7cSYclA*`vCsRK`vKtK+!0;&nH$#>5fAen>C`%y>k^Fm+f`~ z#g>)(oxlG55AGxo-nlSdJvIlTte@pc+pz!?WXCwPVAdyRPq|WLVsN90Wiv!v+Xf(00}I23vkw z*zTS)f??9HXZ!}l%gl6_D-nwt+Sfe4wphHu4s#~6%|%|Jce%Xx4#p`%Yh)1Z9rZXM zbRx8}Az3a*5BTNX-Q(RmZ-vu}RNXQSv%a?NwlVHVxBVaJP;VW@5`~59Pg|`x@fUUB zmr<;_?W%sE;V0LSQSh#o=%ty4(chCijH|f%6|w7DWvBa;q>lsA{U?p3(Obh#N6vzE zqrF;VRt!Vw3}3NU%FPCvRR-tKJT;KN2a~}VGsGHRZVXUc*?$tH{RZP1Bjxwi<`#co z+5A=Ui-^W9o#6m!>DzDgm)wr;kF${Mae$5kBJgRfF5Qg#**Kq zI{E^Z;FRKjOAoO9+3^*|WA5`-Df+}h;E8CA(dND9zALYdlb-=Kl|F9@bX33QB!glV zC2PYL@VUuu;j7s|P6BHq4r{l@z0H7)a07~j2JJcbqOXAk{`Auz8V5>4$sY72XcJ4X zZDLsjPGk*ZEzCmG?(?;O1zYyMfek8n8|&=S_Tg64$I{$WW)Bbknl?zzFcRPZp)J#k z4c_KY{I_+CV(mL*BDjsF>-ii^wxbQCI-m@@3(gXOy%zx&I(Ibc@39gI?>$xSun{i~ zj0IS4Hw9%#!@NI>L4gZ0QXew=#5JROvCI)GB8VQt%c}k5-j7q-2ai&(&0RhM{^g-N z&k}b9gxt(6Xm#d5s%-EvG)4ics*^$z{fEE$T*81WIZBN`~ zy3#xV!&m~`f_CbobtP6a;j(3Ibb-h#>_xPxI-# zZUul@Apd+`{STYwp6w1HYVo`FEYmmRdr*530DWlwJqBcz=Ap)GpEr;tLHFgc;Zm&F z)NL;fm7~*2K%Y|FE+WabeTUL1&umBbAV* zL@2@oQ(g*l{l8-pd*pFb=Jm7wFth%95YDd)zZNy2M|LMCUVd6t{ugX>^5pnG zR5q_PBF}3q7_H6wRl(wCA4P6v#QH=jC$?q+nozG`L4XEt*Akk?fmZA#027HU?m6_0 z5H0#bQyZOxK(_BYW1~c3lW<`fm9k;g`4!&C{vfDzJ_B|&R=xCGqHGP|OC)=~0<&FT z6XU~90l3~D#;$Xj8>_}LfvKVc#wDE@X&Hl!&?a7>V2kb=)anm-!Kx4dEc`F?ueAO` z3J)E`O{5S+$1P2#1s0-e(>!U@`* zOCm$n1l*?;6kAfj2?)0zfk6aY$+5e{BT!4CneS(yCr%2E3-2E%x?+DGe*^Cm~E@V&uNN~!{uE2NpKg| zEIZ6wq3_v>CsBU~0h0t1X(~bl)LOXWiAF}qh!`yr&!4Jt;l^3(=pE^2$*FcbC z0^BQzxw_0Fkpk~N8|fm171ERV*%?z~2@llwE{oD-r3#i3qKz1cVha>T#r{v!}BHI#T?6_t_Pibsy4&Lwc*5 zhkF%;xpz;0bKZ6`jCbKQ5Q3QmcLvpTw8pDV{#Jog91%D#fZpdNWB@cwfo5Nbd?%o} z*#zvG<4l1qV(&45LLBU9-9tD`#axs=+g)brr7>n~h6&7sRcmJ%H}NV5aCrI}R+RyV zN#U5-SU)Yd*|l@uWD-@sx-)ve{Xjde`JaDfL{i0*J#cCJYyIWFNgw69_qta?NN@p7 z%I88$j3CE*Ig9{1XLZCZIB5-%>pl06H~I^IV*gngXjGxY$dBVukyrxE`g#B+ek_J! zN!kxVKF>#sD(76nea=wj`2hA+C>bW-WDh{UBjcex!1yaxmuEFo9*086 zap=$~7!#qH!Hz`02Ju2{^xn8JQ667gNUiC731DnjE|DZaq83oRH{q`Z2oyJ=fU-A> z49bIjdm^_pL^ee1bY$l{WBO3uyUKUl6YQY|WU{s}d~rukVk*651Hz#6W(2=N5=wd# zr*LWo02-8QqF2(~<&G49sa(AE<21EWc^p&VP~j-8Yhvx`5jQm@pH|{7TKmLXp=#C~ zLfHUP>y;>`Ba49O#_xL1Sn&>@=A=3;V3nsuNSgP2wTL}aM!mCE08 zvGbsRc(rYO@!uD;{R*=mmT;=#h;R_2?!wbpXhuA?F@mXO2$jpNpfi<0u1Cu~LU8#( z9U;)+Tm+QDtDuMUOBNkQ@p^h%!IN--y_WM+FjFTFRQT^R>lH5&C(5e;JxiX;Pl#iD zz=E;7U!PSCh6>c(#v2-dv6aU=h9}A~ULvv+!CT=N0IQv~)d!WKFpVwHj0E7>vbOMS z+sdDdavE zsn;F?k0$p@=)_WkYG|7#M6$9;0*?~H0>$6tR8L@YOfShXT4ku~pELU8t`P;Jrk zhmzExIV}+>&gephU>GrsVFicjsMYk>Y{36Ka?%QU2s)~|a&|~c{_)NWX!WW7BUIMP zCCFYyNFE^h;HJ-L-B$wvEjwf%FA%9hfemkkIYj7XrPJUQKA`n9N}#~ropQsUV1Vx` z;6_cVWLF?MDn%#=dERG66%p+v;D`s&K5dv2?R7z3C;-^k9S_XFbmj}-r=xp#XaYFh z!sbH{@rt|yrY6*`wrqv%=_ygO>rnp*vdu4E{q@wOE9WZoZq1UMpik@L5UUOug>dN_ zfa3yTybjDAtdYE!9qc_0*Dr@~$7p}ef(7KEu@HkAWwrvwr!$gxV|7^EXTDnIt97pf z@Ff*BECv_#TAR~bRxp(bVcTB_af%j5rPy`eNE~{@@61EmlX z;Fsym5?j%tDa(n}a;z48$^r-&ka;M;vRj>TgRjqzeJApo5%m|j2Czz!3TrZ9%pFN` zPpL0vr@3xz87HZeeG5E%MScW>O5B^1;h0AR_79$tl9HzGF@XEt(p!W{kS=s4qQ|rW zDrn_JI90jp(_QZFoH*G|21~2`PdQXxCG|^thL_zP4Q9iAM#Uw~F+UzD7XKW^+6JHv zJqTL>IP7=Dpz0lzJ|B5$kMR&=!vm~$b3&|Is3I+rIWjA&KN7os5v8}kj_IrwDX$P& zZjCs+b!*)?0nZ}Q1P<66yPrq=56k+y3NxZ2$X?we)O-H$o1Tz`Rr+%>mI~l~2aiVL zW1R4MZ?e%D2Ig$DecAg;P<;&$W|yz!k3>Da12Xrx7$_u^QR5xq_))wAaiogbL!+}= z0O3VIx%nfP&=R&v7}{b3++_N^0e=t7TnfUn(DNjxFA7-Kjk8BcI(00<)QRSb8Bkgg z9X_kb0b}j;T(ZPxG6LK-R(fSD?xZ2tIUv~zQ7awBv1Stt0G|m(4kj7<*mN}cWC?>W z$6C0$6~#37rS~Gd3anXsevXPZ%?_YHbf$o-(t_P(WSktO7slTMh#JPp(k-xrU#ha zK^Kyo2ck7F)jJ82{<*ENN0)Y&Ak6i_nxxS9R26Db#|#lzloB;XoW1y=bLB?$Tpb}# z0xwLGdtDNP5=WU+n`u{GFLrT?6QTHpREP}`_V`w7&OKeU2~mkYDzaA&w!NJf!;Y{F zxDy)G>s(%2g>fJTG_>YI6Z`fDQFH--5>3N9fj;K21BkoxeDqW=oVUnTfP81A0lu=m zrxpT5(BOO&TIo+Lx(pfX2);eHNrA-Q0`gGixEw69B@dBQ7AwIWsGuayd3-CRLMX)h z=K*FgI|d-cEwl7@?^ePYuV9_{(pgRC1zeu<5zM$|;c~qG=fxi?l5*_2I;$fBdx% z;QMmLN=^Tf+=-xYu<64);JN*3AMx_Ogd$Rf+`G-EfDT4kW>qeb;}Ee%(|4lmCigNJ z)BTEnZ0;0o#v{-*%~>Slc+`mTo}ER7H<>fn>vymK5V^O%bJ9*hI5Zj3 zX!Q&6=@{^lXjAw(hNX;vYyAOW6iG$Tsg+8sQ4q@&z*=LI>+==?;F6As1=L`~YAmFQ zpEd~wo!_m92$_~vV1Q3S5C-=&ALapEW^?ohQi3_2L%Jlu_Edv^%my(&X#!h1t@cmD zptoqjjzRP)7;npswM9B6f7d5o9Cz_!ct&<6|Cf!JugVTbG5KqqFJ-kU)>8t;{1Xt# zp5cHg>ceMld&1x+%P5ArMT}J;%*6SC#c3E5=lUd64SSF6Stc6Zj|@MBj0YR$>-FSr zCrVB3d8v;LpCh)-+?xi8Nb9WCWBQ`VDLUhdDYQ#&%!K$In$KQ~T=}d9l_o~Oc2`@g zIpq4n#x1VKi&c2fT^KIaovY%{C zC6DtCor8zRWatcJIYFt72=si$Mo* z@y}h8*v$;g+eRYV&rcB{_7h$y4hYpvSblIPe1WiQwgGMISyfe085$4XV`ZlQA%49Z z8k!agsG)g(g0yM=mIefSnww}hDbDNeeU%fFyVaz3VO9}-kHNt4|L(c`&C~XK5RFOt z6YQXJ!@cYjv*II*N-6rcsrLqCfJqWIHe#n2QDTTlUXpFR)Z;qQUJE^-61m8!4wJCC zT(aqDUNmMv&o!?`OxLt;{=f0fV74x$-TMJ!Z`oRRg;>6; z$R*#n*llfGdk}~ot`rPq+0Ao#l=;v(`L3Xn9u%Kgu9^d@m`qT-YRLGzefvY8N;TNg zOsYsMm$`ShqwTuep%4rea96%Mqg$4v6=qUxqkVT;A1drN)i5&Bt$683l2vUtut)rY zTII4H*BA`q+n^nd_FA)0g{Fy&_`2Zsb}z4U7L<2n4nZ7fP|k4(@lOdtP*Yj>OMGKi zT&6Bb72<0j#v2CrTGES>$KM)%SJ})E6gOotSv6f|Zq|qI+V$P`!&SjA(g=w^6fATY zliTo~z2?C_uL}uu#{w{uoBSN79s`R!n(@mr6cV(<%mGx6LXSU4q)kZ^E*IYR%nhd9 zcB6MxOC0>!dQ0!n1PyJO$mx^NvC+^c$5Y3Cj@fw|qrU-!46{U6>_AGc!^`w<7j^MJ ztCjqmB@nNDG9U2avRHeqcst7kG%p`Tl|YSl5W+oZL-65qt5(F)EF^>zmL8l)uxfM| z4Tlsasy`50;J#cXk%tL{GUucROiELCO0qY}NOR6R;Gq;v(GUmVZN7s*F7}EGPy3*w z>PV>c27LY{gpk~s2md2C{@Zd&h@t%XA-BsP?~zD?8kcvorR?3bd!WHz8uxVr&A)Nd z03;@ZP_nq3l<38a_D*H-B?FKT0sR-;?cQ2cqG3)PXIjI2C^5oXgkbsCyop^!Xg37d z+4!z(c=!_r0DGYj!_R ztd>DZ9NM(&Q+kb%9NOlB6+}DC_=OD~g7-sk6tFc)J&xn->hr+AKz%C=XvHE7-6NB0 zfqUc!;Bc~7USl(uc{NlkVl!uo)TIByinWQk= z66&iarlXR(Xg@mu8x)OG9|-6xG>HW52}8PfzS1Nlbx}@{5TIw-q96&>BN|4<0wBmJ z<8nhKci^j#Ybu;;kQ)qhn*3^CI4_kQ@dZ%%)R=Gx2n5QOVN*7B(K;+?^%AM8c9=` z;8w8o4KCJIXUeIaG^H=V2HD$(nQyUw#l5@csczO&p!(#=6O*5#PAgt?X8zz&YRjBf z(b`VLpCK8EEMU~+Hf2LmQrD^62kH<7DO)qBF20%^hx%RaLi7Sw@Eh$I3=Jz?6&44! zW65M%kqJAJJ0i>bwMK}N>xWSD^Hg9t+8fwrjaXI+f zQsKcO334-%1I4UTVX8O=6Zmy#GHXb`FTO~BulAS~J+1Y{K0S)wV^sv0>CM0*Sd3kg zsHn*a_kFD!nKR9LVL1^LUm)$er7c;u!`{3d{QpP2>E8&ve}>-B=Y(ymX?t{Yyd;uK z*)#q264SP2cv!a;^ZdBtfd^J-AXgaJdH7K>|JPP7g%9)zo^`hX4v=@Se)Z)x5Z0Q@!1$vCPfz7bRQSL zTLda;qjX1z74+bbf{+{WjV7^bOW?$)*i9m$^KJ_E$q!E+&Yt`UNT81U+|^!uk7i)r zm%N*>BYq)r5STS6iPM@CmDADKsf=M*r%2Jpx>GK2Oq&kni8E1aQk zQv8b8@(0%!EFt_@EoE5O!Bf|QS;ohe09!Zl49@fUD!9HmhdXlpX*g8r-=ldX(*W8Q zx;ZJpHs5$O^WZ8YL+?Yc`UhurfFEa}#4z>UzuzK>ZVQO{$QR)oROPm2u0U#LP-UXX zxVDPy(R~oDt2fUNA(&;A4i&LYeXrnXVFCr7Jm!u#;jymgqDm)ljH$2RyLT_rOR|`Z z3W}*{GYFLG!kA!Ha5@B!kvCGIi`A7mvI?opw)7*6E&VU zSN|5cLIb-J;_`;E)}$_AnMaf-CTqqw??UGHJS+ZI1nqZ2cG@cmx^@8{;0s3#6LJ=8 zPEv<1LMdht+OnC2apRitSB`X+uX?Hrl^!Ygp<{*8d#&MGL*WTX0<#9X2w{>f9PviC zJScj2MffMLI`um*=k-wqH}0`zV1nM&0~s%CM>AtJRBmI1Ulp{nc5zSru%;%*8D4xm zl)?8S*aLezjUWhET#&V7LZTHzSpH$NRL0EIw~#J0{CRbCo#`O8{9jxm_=v`hNlU~F zYGdD5562bvW_htsPbu*uDs^`W{yib$&5G4uUPmLqiET>RHzjiP*0{q$#Ord|Zstel0&p6T`x2c7px`sfRk`vUZB0+led ze*#ty*qK@Zd#FrAoa$>{BW4(CzLc8>5$HC8w!t=T+2zaRbO$qzNSV>fE;)0w``IJ%_XILi+joE%{Bcyhk=o zZjvajTo=y%kFNcF)CT|1`mi2aJpUN(c|ckh?sw2v8B7H49wkwyD4VL4IfA@9wRe=k ziZvO?0Q^l9nt}{>b#$*i6$?z)ucl?0ZgBRM(ad=H>Q#H#%rrNbhh%0LjdLPSAae1s zf%GXX?h^ipDOZxX@ERu+4tiVn8SOhmiT8=6&$gGMR{Md$8uiI7CHmj~ospChiD#OU z_n+MkDb%_*4CJug4JsIbOAcT zB8!7SZG8gzdKa1+Eo6xuji2KwO7H8jTl(df&{A)RoH;(-S^y)Yzu{K z-=cM_u^>#dlXLn|pOI?%%0^q37#Y%nKs_uO^{OF}ufE)GC1s;v^cS4k@pA#)9ao9y>bf zyz!zGlDqkdy){MKobaCYZbW8$2LK9>10j0NwR8pPm=`tcF71dYasw&;7Qzto>=dj< zy$4Zsrx>TIw7T6y+bxj`re3edKEjA~l0VGi9F+&-cx8Jcif#r9Pa=yNk*9M+S82TN zQFZvNlT9DA5YD)n(%*lVQ&4M%7fx#b^puCxSmWlXqXYnZv;GG5qQnXLRWw-u)hQ?f z)T;4plXH-MAY58jE!2v{@$lqNbxJ$g$NHmz$hgU=1JHs&)swqB15hb;jE5aME{iK~ z7FXlx?2Vuo=Gl$Q8GZOLZQFT$=(PB!B7hGa!QJUt9-x|e%MgvM@Bg3|`7=;lM(tFF zZ*zYSq3paTm1+s?o&pO&MXc5M@Z5_-E;_b|WDJO^>h~F)#Q&iT@$&>68B_&%lg?aM z%`kk1)r&O)@YC9>&r6Ya{d2FBPp9^A4_MVKnu2@GB{ty#6u zF|+!d$1%%hTLqF(kmZq$1((d{w*56G=ryKJ3npI*1%IbVhx=i zwgY;PDrI!Sw#Sm)EvQ^mGq&5BINxq0g&Bwc%6E*Y0Syy2}-c zi>vm;#f@dx8TbogBIa_;(Pp zcH&I~0E+*})&I`tH(yCOfGKM~^ym8|!VqqSoVWW9o4+3b3_U{T-1`|{etDWsZU!z? zUhro|qtcbH3OTVn_*}}-+gyf?c^aiB5ZzNJA8pνlE{7JycvQuckoD~z~m)pRZ2 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

    G*-8sPjMRCA6 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

    RbmfcQ{ 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∈-ReU2MvyaHoZpW=#`_mRVRlSl$CT5eMBN&% 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 W$C9_v7UXY$|4xa^9!~{@@Babx!K%;z literal 0 HcmV?d00001 diff --git a/examples/zch/main.py b/examples/zch/main.py new file mode 100644 index 000000000..18b114b3b --- /dev/null +++ b/examples/zch/main.py @@ -0,0 +1,131 @@ +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict + +import argparse +import time + +import torch + +from torchrec import EmbeddingConfig, KeyedJaggedTensor +from torchrec.distributed.benchmark.benchmark_utils import get_inputs +from tqdm import tqdm + +from .sparse_arch import SparseArch + + +def main(args: argparse.Namespace) -> None: + """ + This function tests the performance of a Sparse module with or without the MPZCH feature. + Arguments: + use_mpzch: bool, whether to enable MPZCH or not + Prints: + duration: time for a forward pass of the Sparse module with or without MPZCH enabled + collision_rate: the collision rate of the MPZCH feature + """ + print(f"Is use MPZCH: {args.use_mpzch}") + + # check available devices + device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") + # device = torch.device("cpu") + + print(f"Using device: {device}") + + # create an embedding configuration + embedding_config = [ + EmbeddingConfig( + name="table_0", + feature_names=["feature_0"], + embedding_dim=8, + num_embeddings=args.num_embeddings_per_table, + ), + EmbeddingConfig( + name="table_1", + feature_names=["feature_1"], + embedding_dim=8, + num_embeddings=args.num_embeddings_per_table, + ), + ] + + # generate kjt input list + input_kjt_list = [] + for _ in range(args.num_iters): + input_kjt_single = KeyedJaggedTensor.from_lengths_sync( + keys=["feature_0", "feature_1"], + # pick a set of 24 random numbers from 0 to args.num_embeddings_per_table + values=torch.LongTensor( + list( + torch.randint( + 0, args.num_embeddings_per_table, (3 * args.batch_size,) + ) + ) + ), + lengths=torch.LongTensor([1] * args.batch_size + [2] * args.batch_size), + weights=None, + ) + input_kjt_single = input_kjt_single.to(device) + input_kjt_list.append(input_kjt_single) + + num_requests = args.num_iters * args.batch_size + + # make the model + model = SparseArch( + tables=embedding_config, + device=device, + return_remapped=True, + use_mpzch=args.use_mpzch, + buckets=1, + ) + + # do the forward pass + if device.type == "cuda": + torch.cuda.synchronize() + starter = torch.cuda.Event(enable_timing=True) + ender = torch.cuda.Event(enable_timing=True) + + # record the start time + starter.record() + for it_idx in tqdm(range(args.num_iters)): + # ec_out, remapped_ids_out = model(input_kjt_single) + input_kjt = input_kjt_list[it_idx].to(device) + ec_out, remapped_ids_out = model(input_kjt) + # record the end time + ender.record() + # wait for the end time to be recorded + torch.cuda.synchronize() + duration = starter.elapsed_time(ender) / 1000.0 # convert to seconds + else: + # in cpu mode, MPZCH can only run in inference mode, so we profile the model in eval mode + model.eval() + if args.use_mpzch: + # when using MPZCH modules, we need to manually set the modules to be in inference mode + # pyre-ignore + model._mc_ec._managed_collision_collection._managed_collision_modules[ + "table_0" + ].reset_inference_mode() + # pyre-ignore + model._mc_ec._managed_collision_collection._managed_collision_modules[ + "table_1" + ].reset_inference_mode() + + start_time = time.time() + for it_idx in tqdm(range(args.num_iters)): + input_kjt = input_kjt_list[it_idx].to(device) + ec_out, remapped_ids_out = model(input_kjt) + end_time = time.time() + duration = end_time - start_time + # get qps + qps = num_requests / duration + print(f"qps: {qps}") + # print the duration + print(f"duration: {duration} seconds") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser() + parser.add_argument("--use_mpzch", action="store_true", default=False) + parser.add_argument("--num_iters", type=int, default=100) + parser.add_argument("--batch_size", type=int, default=8) + parser.add_argument("--num_embeddings_per_table", type=int, default=1000) + args: argparse.Namespace = parser.parse_args() + main(args) diff --git a/examples/zch/sparse_arch.py b/examples/zch/sparse_arch.py new file mode 100644 index 000000000..b8be4abaa --- /dev/null +++ b/examples/zch/sparse_arch.py @@ -0,0 +1,137 @@ +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict + +from typing import Dict, List, Optional, Tuple, Union + +import torch +from torch import nn + +from torchrec import ( + EmbeddingCollection, + EmbeddingConfig, + JaggedTensor, + KeyedJaggedTensor, + KeyedTensor, +) + +# For MPZCH +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) + +# For MPZCH +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection + +# For original MC +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + MCHManagedCollisionModule, +) + +""" +Class SparseArch +An example of SparseArch with 2 tables, each with 2 features. +It looks up the corresponding embedding for incoming KeyedJaggedTensors with 2 features +and returns the corresponding embeddings. + +Parameters: + tables(List[EmbeddingConfig]): List of EmbeddingConfig that defines the embedding table + device(torch.device): device on which the embedding table should be placed + buckets(int): number of buckets for each table + input_hash_size(int): input hash size for each table + return_remapped(bool): whether to return remapped features, if so, the return will be + a tuple of (Embedding(KeyedTensor), Remapped_ID(KeyedJaggedTensor)), otherwise, the return will be + a tuple of (Embedding(KeyedTensor), None) + is_inference(bool): whether to use inference mode. In inference mode, the module will not update the embedding table + use_mpzch(bool): whether to use MPZCH or not. If true, the module will use MPZCH managed collision module, + otherwise, it will use original MC managed collision module +""" + + +class SparseArch(nn.Module): + def __init__( + self, + tables: List[EmbeddingConfig], + device: torch.device, + buckets: int = 4, + input_hash_size: int = 4000, + return_remapped: bool = False, + is_inference: bool = False, + use_mpzch: bool = False, + ) -> None: + super().__init__() + self._return_remapped = return_remapped + + mc_modules = {} + + if ( + use_mpzch + ): # if using the MPZCH module, we create a HashZchManagedCollisionModule for each table + mc_modules["table_0"] = HashZchManagedCollisionModule( + is_inference=is_inference, + zch_size=( + tables[0].num_embeddings + ), # the zch size, that is, the size of local embedding table, should be the same as the size of the embedding table + input_hash_size=input_hash_size, # the input hash size, that is, the size of the input id space + device=device, # the device on which the embedding table should be placed + total_num_buckets=buckets, # the number of buckets, the detailed explanation of the use of buckets can be found in the readme file + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, # the eviction policy name, in this example use the single ttl eviction policy, which assume an id is evictable if it has been in the table longer than the ttl (time to live) + eviction_config=HashZchEvictionConfig( # Here we need to specify for each feature, what is the ttl, that is, how long an id can stay in the table before it is evictable + features=[ + "feature_0" + ], # because we only have one feature "feature_0" in this table, so we only need to specify the ttl for this feature + single_ttl=1, # The unit of ttl is hour. Let's set the ttl to be default to 1, which means an id is evictable if it has been in the table for more than one hour. + ), + ) + mc_modules["table_1"] = HashZchManagedCollisionModule( + is_inference=is_inference, + zch_size=(tables[1].num_embeddings), + device=device, + input_hash_size=input_hash_size, + total_num_buckets=buckets, + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, + eviction_config=HashZchEvictionConfig( + features=["feature_1"], + single_ttl=1, + ), + ) + else: # if not using the MPZCH module, we create a MCHManagedCollisionModule for each table + mc_modules["table_0"] = MCHManagedCollisionModule( + zch_size=(tables[0].num_embeddings), + input_hash_size=input_hash_size, + device=device, + eviction_interval=2, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) + mc_modules["table_1"] = MCHManagedCollisionModule( + zch_size=(tables[1].num_embeddings), + device=device, + input_hash_size=input_hash_size, + eviction_interval=1, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) + + self._mc_ec: ManagedCollisionEmbeddingCollection = ( + ManagedCollisionEmbeddingCollection( + EmbeddingCollection( + tables=tables, + device=device, + ), + ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=tables, + ), + return_remapped_features=self._return_remapped, + ) + ) + + def forward( + self, kjt: KeyedJaggedTensor + ) -> Tuple[ + Union[KeyedTensor, Dict[str, JaggedTensor]], Optional[KeyedJaggedTensor] + ]: + return self._mc_ec(kjt) diff --git a/examples/zch/zero_collision_hash_tutorial.ipynb b/examples/zch/zero_collision_hash_tutorial.ipynb new file mode 100644 index 000000000..547601897 --- /dev/null +++ b/examples/zch/zero_collision_hash_tutorial.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zero-collision Hash Tutorial\n", + "This example notebook goes through the following topics:\n", + "- Why do we need zero-collision hash?\n", + "- How to use the zero-collision module in TorchRec?\n", + "\n", + "## Pre-requisite\n", + "Before dive into the details, let's import all the necessary packages first. This needs you to [have the latest `torchrec` library installed](https://docs.pytorch.org/torchrec/setup-torchrec.html#installation)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 1181435817001907, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "I0611 161033.883 _utils_internal.py:282] NCCL_DEBUG env var is set to None\n", + "I0611 161033.885 _utils_internal.py:291] NCCL_DEBUG is WARN from /etc/nccl.conf\n", + "I0611 161039.736 pyper_torch_elastic_logging_utils.py:234] initialized PyperTorchElasticEventHandler\n" + ] + } + ], + "source": [ + "import torch\n", + "from torch import nn\n", + "from torchrec import (\n", + " EmbeddingCollection,\n", + " EmbeddingConfig,\n", + " JaggedTensor,\n", + " KeyedJaggedTensor,\n", + " KeyedTensor,\n", + ")\n", + "\n", + "from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection\n", + "\n", + "from torchrec.modules.mc_modules import (\n", + " DistanceLFU_EvictionPolicy,\n", + " ManagedCollisionCollection,\n", + " MCHManagedCollisionModule,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hash and Zero Collision Hash\n", + "In this section, we present the motivation that\n", + "- Why do we need to perform hash on incoming features?\n", + "- Why do we need to implement zero-collision hash?\n", + "\n", + "Let's first take a look in the question that why do we need to perform hashing for sparse feature inputs in the recommendation model? \n", + "We firstly create an embedding table of 1000 embeddings." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define the number of embeddings\n", + "num_embeddings = 1000\n", + "table_config = EmbeddingConfig(\n", + " name=\"t1\",\n", + " embedding_dim=16,\n", + " num_embeddings=1000,\n", + " feature_names=[\"f1\"],\n", + ")\n", + "ec = EmbeddingCollection(tables=[table_config])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Usually, for each input sparse feature ID, we regard it as the index of the embedding in the embedding table, and fetch the embedding at the corresponding slot in the embedding table. However, while embedding tables is fixed when instantiating the models, the number of sparse features, such as tags of videos, can keep growing. After a while, the ID of a sparse feature can be larger the size of our embedding table." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "feature_id = num_embeddings + 1\n", + "input_kjt = KeyedJaggedTensor.from_lengths_sync(\n", + " keys=[\"f1\"],\n", + " values=torch.tensor([feature_id]),\n", + " lengths=torch.tensor([1]),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "At that point, the query will lead to an `index out of range` error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 1225052112737471, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query the embedding table of size 1000 with sparse feature ID tensor([1001])\n", + "This query throws an IndexError: index out of range in self\n" + ] + } + ], + "source": [ + "try:\n", + " feature_embedding = ec(input_kjt)\n", + "except IndexError as e:\n", + " print(f\"Query the embedding table of size {num_embeddings} with sparse feature ID {input_kjt['f1'].values()}\")\n", + " print(f\"This query throws an IndexError: {e}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To avoid this error from happening, we hash the sparse feature ID to a value within the range of the embedding table size, and use the hashed value as the feature ID to query the embedding table. \n", + "\n", + "For the purpose of demonstration, we use Python's built-in hash function to hash an integer (which will not change the value) and remap it to the range of `[0, num_embeddings)` by taking the modulo of `num_embeddings`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def remap(input_jt_value: int, num_embeddings: int):\n", + " input_hash = hash(input_jt_value)\n", + " return input_hash % num_embeddings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can query the embedding table with the remapped id without error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 990950286247121, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Query the embedding table of size 1000 with remapped sparse feature ID 1 from original ID 1001\n", + "This query does not throw an IndexError, and returns the embedding of the remapped ID: {'f1': }\n" + ] + } + ], + "source": [ + "remapped_id = remap(feature_id, num_embeddings)\n", + "remapped_kjt = KeyedJaggedTensor.from_lengths_sync(\n", + " keys=[\"f1\"],\n", + " values=torch.tensor([remapped_id]),\n", + " lengths=torch.tensor([1]),\n", + ")\n", + "feature_embedding = ec(remapped_kjt)\n", + "print(f\"Query the embedding table of size {num_embeddings} with remapped sparse feature ID {remapped_id} from original ID {feature_id}\")\n", + "print(f\"This query does not throw an IndexError, and returns the embedding of the remapped ID: {feature_embedding}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After answering the first question: __Why do we need to perform hash on incoming features?__, now we can answer the second question: __Why do we need to implement zero-collision hash?__\n", + "\n", + "Because we are casting a larger range of values into a small range, there will be some values being remapped to the same index. For example, using our `remap` function, it will give the same remapped id for feature `num_embeddings + 1` and `1`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 1024965419837378, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "feature ID 1 is remapped to ID 1\n", + "feature ID 1001 is remapped to ID 1\n", + "Check if remapped feature ID 1 and 1 are the same: True\n" + ] + } + ], + "source": [ + "feature_id_1 = 1\n", + "feature_id_2 = num_embeddings + 1\n", + "remapped_feature_id_1 = remap(feature_id_1, num_embeddings)\n", + "remapped_feature_id_2 = remap(feature_id_2, num_embeddings)\n", + "print(f\"feature ID {feature_id_1} is remapped to ID {remapped_feature_id_1}\")\n", + "print(f\"feature ID {feature_id_2} is remapped to ID {remapped_feature_id_2}\")\n", + "print(f\"Check if remapped feature ID {remapped_feature_id_1} and {remapped_feature_id_2} are the same: {remapped_feature_id_1 == remapped_feature_id_2}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this case, two totally different features can share the same embedding. The situation when two feature IDs share the same remapped ID is called a **hash collision**." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 923188026604331, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Embedding of feature ID 1 is tensor([ 0.0232, 0.0075, 0.0281, -0.0195, -0.0301, 0.0033, 0.0303, 0.0294,\n", + " 0.0301, -0.0287, -0.0130, -0.0194, 0.0263, 0.0287, 0.0261, -0.0080],\n", + " grad_fn=)\n", + "Embedding of feature ID 1 is tensor([ 0.0232, 0.0075, 0.0281, -0.0195, -0.0301, 0.0033, 0.0303, 0.0294,\n", + " 0.0301, -0.0287, -0.0130, -0.0194, 0.0263, 0.0287, 0.0261, -0.0080],\n", + " grad_fn=)\n", + "Check if the embeddings of feature ID 1 and 1 are the same: True\n" + ] + } + ], + "source": [ + "input_kjt = KeyedJaggedTensor.from_lengths_sync(\n", + " keys=[\"f1\"],\n", + " values=torch.tensor([remapped_feature_id_1, remapped_feature_id_2]),\n", + " lengths=torch.tensor([1, 1]),\n", + ")\n", + "feature_embeddings = ec(input_kjt)\n", + "feature_id_1_embedding = feature_embeddings[\"f1\"].values()[0]\n", + "feature_id_2_embedding = feature_embeddings[\"f1\"].values()[1]\n", + "print(f\"Embedding of feature ID {remapped_feature_id_1} is {feature_id_1_embedding}\")\n", + "print(f\"Embedding of feature ID {remapped_feature_id_2} is {feature_id_2_embedding}\")\n", + "print(f\"Check if the embeddings of feature ID {remapped_feature_id_1} and {remapped_feature_id_2} are the same: {torch.equal(feature_id_1_embedding, feature_id_2_embedding)}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Making two different (and potentially totally irrelavant) features share the same embedding will cause inaccurate recommendations.\n", + "Lukily, for many sparse features, though their range can be larger than the the embedding table size, their IDs are sparsely located on the range.\n", + "In some other cases, the embedding table may only receive frequent queries for a subset of the features.\n", + "So we can design some __managed collision hash__ modules to avoid the hash collision from happening." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TorchRec Zero Collision Hash Modules\n", + "\n", + "TorchRec implements managed collision hash strategies such as *sorted zero collision hash* and *multi-probe zero collision hash (MPZCH)*.\n", + "\n", + "They help hash and remap the feature IDs to embedding table indices with (near-)zero collisions.\n", + "\n", + "In the following content we will use the MPZCH module as an example for how to use the zero-collision modules in TorchRec. The name of the MPZCH module is `HashZchManagedCollisionModule`.\n", + "\n", + "Let's assume we have two tables: `table_0` and `table_1`, each with embeddings for `feature_0` and `feature_1`, respectively." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# define the table sizes\n", + "num_embeddings_table_0 = 1000\n", + "num_embeddings_table_1 = 2000\n", + "\n", + "# create table configs\n", + "table_0_config = EmbeddingConfig(\n", + " name=\"table_0\",\n", + " embedding_dim=16,\n", + " num_embeddings=num_embeddings_table_0,\n", + " feature_names=[\"feature_0\"],\n", + ")\n", + "\n", + "table_1_config = EmbeddingConfig(\n", + " name=\"table_1\",\n", + " embedding_dim=16,\n", + " num_embeddings=num_embeddings_table_1,\n", + " feature_names=[\"feature_1\"],\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before turning the table configurations into embedding table collection, we instantiate our managed collision modules.\n", + "\n", + "The managed collision modules for a collection of embedding tables are intended to format as a dictionary with `{table_name: mc_module_for_the_table}`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mc_modules = {}\n", + "\n", + "# Instantiate the module, we provide detailed comments on\n", + "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu') #\n", + "input_hash_size = 10000\n", + "mc_modules[\"table_0\"] = MCHManagedCollisionModule(\n", + " zch_size=(table_0_config.num_embeddings),\n", + " input_hash_size=input_hash_size,\n", + " device=device,\n", + " eviction_interval=2,\n", + " eviction_policy=DistanceLFU_EvictionPolicy(),\n", + " )\n", + "mc_modules[\"table_1\"] = MCHManagedCollisionModule(\n", + " zch_size=(table_1_config.num_embeddings),\n", + " device=device,\n", + " input_hash_size=input_hash_size,\n", + " eviction_interval=1,\n", + " eviction_policy=DistanceLFU_EvictionPolicy(),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For embedding tables with managed collision modules, TorchRec uses a wrapper module `ManagedCollisionEmbeddingCollection` that contains both the embedding table collections and the managed collision modules. Users only need to pass their table configurations and" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "mc_ec = ManagedCollisionEmbeddingCollection = (\n", + " ManagedCollisionEmbeddingCollection(\n", + " EmbeddingCollection(\n", + " tables=[\n", + " table_0_config,\n", + " table_1_config\n", + " ],\n", + " device=device,\n", + " ),\n", + " ManagedCollisionCollection(\n", + " managed_collision_modules=mc_modules,\n", + " embedding_configs=[\n", + " table_0_config,\n", + " table_1_config\n", + " ],\n", + " ),\n", + " return_remapped_features=True, # whether to return the remapped feature IDs\n", + " )\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `ManagedCollisionEmbeddingCollection` module will perform remapping and table look-up for the input. Users only need to pass the keyyed jagged tensor queries into the module." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 1363945501556497, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "feature name: feature_0, feature jt: JaggedTensor({\n", + " [[1000], [10001]]\n", + "})\n", + "\n", + "feature jt values: tensor([ 1000, 10001])\n", + "feature name: feature_1, feature jt: JaggedTensor({\n", + " [[2000], [20001]]\n", + "})\n", + "\n", + "feature jt values: tensor([ 2000, 20001])\n" + ] + } + ], + "source": [ + "input_kjt = KeyedJaggedTensor.from_lengths_sync(\n", + " keys=[\"feature_0\", \"feature_1\"],\n", + " values=torch.tensor([1000, 10001, 2000, 20001]),\n", + " lengths=torch.tensor([1, 1, 1, 1]),\n", + ")\n", + "for feature_name, feature_jt in input_kjt.to_dict().items():\n", + " print(f\"feature name: {feature_name}, feature jt: {feature_jt}\")\n", + " print(f\"feature jt values: {feature_jt.values()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "output": { + "id": 1555795345806679, + "loadingStatus": "loaded" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "feature name: feature_0, feature embedding: JaggedTensor({\n", + " [[[0.022659072652459145, 0.0053002419881522655, -0.025007368996739388, -0.013145492412149906, -0.031139537692070007, -0.01486812811344862, -0.01133741531521082, 0.0027838051319122314, 0.026786740869283676, -0.010626785457134247, 0.01148480549454689, 0.02036162279546261, 0.013492186553776264, -0.024412740021944046, 0.01599711738526821, -0.02390478551387787]], [[-0.029269251972436905, 0.01744556427001953, 0.024260954931378365, 0.029459983110427856, -0.026435773819684982, -0.0034603318199515343, -0.007642757147550583, -0.02111411839723587, 0.027316255494952202, 0.015309474430978298, 0.03137263283133507, 0.01699884422123432, 0.02302604913711548, -0.015266639180481434, -0.019045181572437286, 0.006964980624616146]]]\n", + "})\n", + "\n", + "feature name: feature_1, feature embedding: JaggedTensor({\n", + " [[[0.009506281465291977, 0.012826820835471153, -0.0017535268561914563, -0.0009170559933409095, -0.014913717284798622, 0.0040654330514371395, -0.011355634778738022, 0.008443576283752918, 0.0007347835344262421, -0.00907053705304861, 0.010160156525671482, 0.016830360516905785, 0.002154064131900668, -0.010799579322338104, -0.0197420883923769, -0.0025849745143204927]], [[-0.020103629678487778, 0.01041398011147976, -0.01699216105043888, 0.01291638519614935, 0.018798867240548134, 0.01616138033568859, -0.020600538700819016, -0.017695769667625427, 0.0100017711520195, -0.010470695793628693, -0.018935278058052063, -0.011798662133514881, -0.014235826209187508, -0.01985463872551918, 0.009744714014232159, -0.004050525836646557]]]\n", + "})\n", + "\n", + "feature name: feature_0, feature jt values: tensor([997, 998], device='cuda:0')\n", + "feature name: feature_1, feature jt values: tensor([1997, 1998], device='cuda:0')\n" + ] + } + ], + "source": [ + "output_embeddings, remapped_ids = mc_ec(input_kjt.to(device))\n", + "# show output embeddings\n", + "for feature_name, feature_embedding in output_embeddings.items():\n", + " print(f\"feature name: {feature_name}, feature embedding: {feature_embedding}\")\n", + "# show remapped ids\n", + "for feature_name, feature_jt in remapped_ids.to_dict().items():\n", + " print(f\"feature name: {feature_name}, feature jt values: {feature_jt.values()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have a basic example of how to use the managed collision modules in TorchRec. \n", + "\n", + "We also provide a profiling example to compare the efficiency of sorted ZCH and MPZCH modules. Check the [Readme](Readme.md) file for more details." + ] + } + ], + "metadata": { + "fileHeader": "", + "fileUid": "ee3845a2-a85b-4a8e-8c42-9ce4690c9956", + "isAdHoc": false, + "kernelspec": { + "display_name": "torchrec", + "language": "python", + "name": "bento_kernel_torchrec" + }, + "language_info": { + "name": "plaintext" + }, + "orig_nbformat": 4 + } +} From 2de3bb3da3ac08988e7da6668bd9925b1ab7e705 Mon Sep 17 00:00:00 2001 From: Zhouyu Li Date: Mon, 16 Jun 2025 14:43:07 -0700 Subject: [PATCH 3/3] Benchamrk framework for torchrec (#3072) Summary: Pull Request resolved: https://github.com/pytorch/torchrec/pull/3072 # Benchmark framework for MPZCH ### Major changes - Add a `benchmark prober` in `torchrec/distributed/benchmark/benchmark_zch_utils.py` to collect and calculate the zero collision hash related metrics like hit count, insert count, and collision count. - Implement a `benchmark_zch_dlrmv2` local testbed in `torchrec/distributed/benchmark/benchmark_zch_dlrmv2.py`, which allows to profile a DLRMv2 model with and without the MPZCH enabled, and record the metrics including ZCH-related metrics, QPS, NE, and AUROC. - Add `mc_adapter` modules in `torchrec/modules/mc_adapter.py`. These modules enable seamless replacement of embedding collection and embedding bag collection modules with the managed collision version. - Add two dictionaries `self.table_name_on_device_remapped_ids_dict` and `self.table_name_on_device_input_ids_dict` in the `HashZchManagedCollisionModule` module in `torchrec/modules/hash_mc_modules.py` to record the remapped identities and input feature values to the MPZCH module on current rank respectively after input mapping. - Add `count_non_zch_collision.py` script to count the collision rate of non-zch modules after performing `murmur_hash3`. - Add the criteo kaggle dataset data loader in `torchrec/distributed/benchmark/data` and revise the `hashes` attribute of data pipeline in the `_get_in_memory_dataloader` function in the `torchrec/distributed/benchmark/data/dlrm_dataloader.py` file to pre-hash the input feature values to the passed-in argument `input_hash_size` (defaultly as 100000). - Note that we can change the `single_ttl` in the `HashZchSingleTtlScorer` module of `torchrec/modules/hash_mc_evictions.py` to change the eviticability of identities in each `HashZchManagedCollisionModule` module, since exiting benchmark workflow only takes several minutes on the subset of the criteo-kaggle dataset. By default the identities become evictable after one hour. This descrepency leads to non-eviction during the profiling process. ### Dataset - [Criteo Kaggle Small](https://drive.google.com/file/d/1__rPcUSa45FHkmnBwivuM7K4nMYWD7b7/view?usp=sharing) - [Criteo Kaggle](https://drive.google.com/file/d/1_lAbXTEOk5vlPGXd4UvTrxGV6sCPer_R/view?usp=drive_link) Differential Revision: D76150895 --- .../benchmark/benchmark_zch_dlrmv2.py | 936 ++++++++++++++++++ .../benchmark/benchmark_zch_utils.py | 240 +++++ .../benchmark/count_non_zch_collision.py | 189 ++++ .../distributed/benchmark/data/__init__.py | 0 .../benchmark/data/dlrm_dataloader.py | 169 ++++ .../benchmark/data/multi_hot_criteo.py | 306 ++++++ torchrec/modules/hash_mc_evictions.py | 5 +- torchrec/modules/hash_mc_modules.py | 20 + torchrec/modules/mc_adapter.py | 188 ++++ 9 files changed, 2052 insertions(+), 1 deletion(-) create mode 100644 torchrec/distributed/benchmark/benchmark_zch_dlrmv2.py create mode 100644 torchrec/distributed/benchmark/benchmark_zch_utils.py create mode 100644 torchrec/distributed/benchmark/count_non_zch_collision.py create mode 100644 torchrec/distributed/benchmark/data/__init__.py create mode 100644 torchrec/distributed/benchmark/data/dlrm_dataloader.py create mode 100644 torchrec/distributed/benchmark/data/multi_hot_criteo.py create mode 100644 torchrec/modules/mc_adapter.py diff --git a/torchrec/distributed/benchmark/benchmark_zch_dlrmv2.py b/torchrec/distributed/benchmark/benchmark_zch_dlrmv2.py new file mode 100644 index 000000000..2cd41501c --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch_dlrmv2.py @@ -0,0 +1,936 @@ +import argparse +import csv +import json +import multiprocessing +import os +import sys +import time + +from typing import cast, Dict, Iterator, List, Optional + +import numpy as np + +import torch +import torch.nn as nn +import torchmetrics # @manual=fbsource//third-party/pypi/torchmetrics:torchmetrics +from pyre_extensions import none_throws +from torch import distributed as dist +from torch.utils.data import DataLoader + +from torchrec.datasets.criteo import ( + CAT_FEATURE_COUNT, + DAYS, + DEFAULT_CAT_NAMES, + DEFAULT_INT_NAMES, + InMemoryBinaryCriteoIterDataPipe, +) +from torchrec.distributed.comm import get_local_size +from torchrec.distributed.mc_modules import ManagedCollisionCollectionSharder + +from torchrec.distributed.model_parallel import ( + DistributedModelParallel, + get_default_sharders, +) +from torchrec.distributed.planner import EmbeddingShardingPlanner, Topology + +from torchrec.distributed.planner.storage_reservations import ( + HeuristicalStorageReservation, +) + +from torchrec.distributed.types import ModuleSharder +from torchrec.models.dlrm import DLRM, DLRMTrain +from torchrec.modules.embedding_configs import EmbeddingBagConfig +from torchrec.modules.embedding_modules import EmbeddingBagCollection +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_adapter import McEmbeddingBagCollectionAdapter + +from torchrec.modules.mc_embedding_modules import ( + ManagedCollisionEmbeddingBagCollection, + ManagedCollisionEmbeddingCollection, +) + +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + MCHManagedCollisionModule, +) +from torchrec.optim.apply_optimizer_in_backward import apply_optimizer_in_backward + +from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor +from torchrec.test_utils import get_free_port +from tqdm import tqdm + +from .benchmark_zch_utils import BenchmarkMCProbe + +from .data.dlrm_dataloader import get_dataloader + + +def parse_args(argv: List[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description="torchrec dlrm example trainer") + parser.add_argument( + "--epochs", + type=int, + default=1, + help="number of epochs to train", + ) + parser.add_argument( + "--batch_size", + type=int, + default=4096, + help="batch size to use for training", + ) + parser.add_argument( + "--drop_last_training_batch", + dest="drop_last_training_batch", + action="store_true", + help="Drop the last non-full training batch", + ) + parser.add_argument( + "--test_batch_size", + type=int, + default=None, + help="batch size to use for validation and testing", + ) + parser.add_argument( + "--limit_train_batches", + type=int, + default=None, + help="number of train batches", + ) + parser.add_argument( + "--limit_val_batches", + type=int, + default=None, + help="number of validation batches", + ) + parser.add_argument( + "--limit_test_batches", + type=int, + default=None, + help="number of test batches", + ) + parser.add_argument( + "--dataset_name", + type=str, + choices=["criteo_1t", "criteo_kaggle"], + default="criteo_kaggle", + help="dataset for experiment, current support criteo_1tb, criteo_kaggle", + ) + parser.add_argument( + "--num_embeddings", # ratio of feature ids to embedding table size # 3 axis: x-bath_idx; y-collisions; zembedding table sizes + type=int, + default=100_000, + help="max_ind_size. The number of embeddings in each embedding table. Defaults" + " to 100_000 if num_embeddings_per_feature is not supplied.", + ) + parser.add_argument( + "--num_embeddings_per_feature", + type=str, + default=None, + help="Comma separated max_ind_size per sparse feature. The number of embeddings" + " in each embedding table. 26 values are expected for the Criteo dataset.", + ) + parser.add_argument( + "--dense_arch_layer_sizes", + type=str, + default="512,256,64", + help="Comma separated layer sizes for dense arch.", + ) + parser.add_argument( + "--over_arch_layer_sizes", + type=str, + default="512,512,256,1", + help="Comma separated layer sizes for over arch.", + ) + parser.add_argument( + "--embedding_dim", + type=int, + default=64, + help="Size of each embedding.", + ) + parser.add_argument( + "--interaction_branch1_layer_sizes", + type=str, + default="2048,2048", + help="Comma separated layer sizes for interaction branch1 (only on dlrm with projection).", + ) + parser.add_argument( + "--interaction_branch2_layer_sizes", + type=str, + default="2048,2048", + help="Comma separated layer sizes for interaction branch2 (only on dlrm with projection).", + ) + parser.add_argument( + "--dcn_num_layers", + type=int, + default=3, + help="Number of DCN layers in interaction layer (only on dlrm with DCN).", + ) + parser.add_argument( + "--dcn_low_rank_dim", + type=int, + default=512, + help="Low rank dimension for DCN in interaction layer (only on dlrm with DCN).", + ) + parser.add_argument( + "--undersampling_rate", + type=float, + help="Desired proportion of zero-labeled samples to retain (i.e. undersampling zero-labeled rows)." + " Ex. 0.3 indicates only 30pct of the rows with label 0 will be kept." + " All rows with label 1 will be kept. Value should be between 0 and 1." + " When not supplied, no undersampling occurs.", + ) + parser.add_argument( + "--seed", + type=int, + help="Random seed for reproducibility.", + default=0, + ) + parser.add_argument( + "--pin_memory", + dest="pin_memory", + action="store_true", + help="Use pinned memory when loading data.", + ) + parser.add_argument( + "--mmap_mode", + dest="mmap_mode", + action="store_true", + help="--mmap_mode mmaps the dataset." + " That is, the dataset is kept on disk but is accessed as if it were in memory." + " --mmap_mode is intended mostly for faster debugging. Use --mmap_mode to bypass" + " preloading the dataset when preloading takes too long or when there is " + " insufficient memory available to load the full dataset.", + ) + parser.add_argument( + "--in_memory_binary_criteo_path", + type=str, + default=None, + help="Directory path containing the Criteo dataset npy files.", + ) + parser.add_argument( + "--synthetic_multi_hot_criteo_path", + type=str, + default=None, + help="Directory path containing the MLPerf v2 synthetic multi-hot dataset npz files.", + ) + parser.add_argument( + "--learning_rate", + type=float, + default=15.0, + help="Learning rate.", + ) + parser.add_argument( + "--eps", + type=float, + default=1e-8, + help="Epsilon for Adagrad optimizer.", + ) + parser.add_argument( + "--shuffle_batches", + dest="shuffle_batches", + action="store_true", + help="Shuffle each batch during training.", + ) + parser.add_argument( + "--shuffle_training_set", + dest="shuffle_training_set", + action="store_true", + help="Shuffle the training set in memory. This will override mmap_mode", + ) + parser.add_argument( + "--validation_freq_within_epoch", + type=int, + default=None, + help="Frequency at which validation will be run within an epoch.", + ) + parser.set_defaults( + pin_memory=None, + mmap_mode=None, + drop_last=None, + shuffle_batches=None, + shuffle_training_set=None, + ) + parser.add_argument( + "--adagrad", + dest="adagrad", + action="store_true", + help="Flag to determine if adagrad optimizer should be used.", + ) + parser.add_argument( + "--collect_multi_hot_freqs_stats", + dest="collect_multi_hot_freqs_stats", + action="store_true", + help="Flag to determine whether to collect stats on freq of embedding access.", + ) + parser.add_argument( + "--multi_hot_sizes", + type=str, + default=None, + help="Comma separated multihot size per sparse feature. 26 values are expected for the Criteo dataset.", + ) + parser.add_argument( + "--multi_hot_distribution_type", + type=str, + choices=["uniform", "pareto"], + default=None, + help="Multi-hot distribution options.", + ) + parser.add_argument("--lr_warmup_steps", type=int, default=0) + parser.add_argument("--lr_decay_start", type=int, default=0) + parser.add_argument("--lr_decay_steps", type=int, default=0) + parser.add_argument( + "--print_lr", + action="store_true", + help="Print learning rate every iteration.", + ) + parser.add_argument( + "--allow_tf32", + action="store_true", + help="Enable TensorFloat-32 mode for matrix multiplications on A100 (or newer) GPUs.", + ) + parser.add_argument( + "--print_sharding_plan", + action="store_true", + help="Print the sharding plan used for each embedding table.", + ) + parser.add_argument( + "--input_hash_size", + type=int, + default=100_000, + help="Input feature value range", + ) + parser.add_argument( + "--num_buckets", + type=int, + default=4, + help="Number of buckets for identity table", + ) + parser.add_argument( + "--profiling_result_folder", + type=str, + default="profiling_result", + help="Folder to save profiling results", + ) + parser.add_argument( + "--use_zch", + action="store_true", + help="If use zch or not", + ) + return parser.parse_args(argv) + + +def hash_kjt( + sparse_features: KeyedJaggedTensor, num_embeddings: int +) -> KeyedJaggedTensor: + """ + convert the values in the input sparse_features to hashed ones in the range of [0, num_embeddings) + """ + hashed_feature_values_dict = {} # {feature_name: hashed_feature_values} + for feature_name, feature_values_jt in sparse_features.to_dict().items(): + hashed_feature_values_dict[feature_name] = [] + for feature_value in feature_values_jt.values(): + feature_value = feature_value.unsqueeze(0) # convert to [1, ] + feature_value = feature_value.to(torch.uint64) # convert to uint64 + hashed_feature_value = torch.ops.fbgemm.murmur_hash3(feature_value, 0, 0) + # convert to int64 + hashed_feature_value = hashed_feature_value.to( + torch.int64 + ) # convert to int64 + # convert to [0, num_embeddings) + hashed_feature_value = ( + hashed_feature_value % num_embeddings + ) # convert to [0, num_embeddings) + # convert to [1, ] + hashed_feature_value = hashed_feature_value.unsqueeze(0) # convert to [1, ] + hashed_feature_values_dict[feature_name].append(hashed_feature_value) + hashed_feature_values_dict[feature_name] = JaggedTensor.from_dense( + hashed_feature_values_dict[feature_name] + ) + # convert to [batch_size, ] + hashed_feature_kjt = KeyedJaggedTensor.from_jt_dict(hashed_feature_values_dict) + return hashed_feature_kjt + + +# def hash_kjt( +# sparse_features: KeyedJaggedTensor, num_embeddings: int +# ) -> KeyedJaggedTensor: +# """ +# convert the values in the input sparse_features to hashed ones in the range of [0, num_embeddings) +# """ +# hashed_feature_values_dict = {} # {feature_name: hashed_feature_values} +# for feature_name, feature_values_jt in sparse_features.to_dict().items(): +# hashed_feature_values_dict[feature_name] = [] +# feature_values = feature_values_jt.values() +# feature_value = feature_values.to(torch.uint64) # convert to uint64 +# hashed_feature_value = torch.ops.fbgemm.murmur_hash3(feature_value, 0, 0) +# # convert to int64 +# hashed_feature_value = hashed_feature_value.to(torch.int64) # convert to int64 +# # convert to [0, num_embeddings) +# hashed_feature_value = ( +# hashed_feature_value % num_embeddings +# ) # convert to [0, num_embeddings) +# # convert to [1, ] +# # hashed_feature_value = hashed_feature_value.unsqueeze(0) # convert to [1, ] +# # hashed_feature_values_dict[feature_name].append(hashed_feature_value) +# hashed_feature_values_dict[feature_name] = JaggedTensor.from_dense( +# hashed_feature_value +# ) +# # convert to [batch_size, ] +# hashed_feature_kjt = KeyedJaggedTensor.from_jt_dict(hashed_feature_values_dict) +# return hashed_feature_kjt + + +def main(rank: int, args: argparse.Namespace, queue: multiprocessing.Queue) -> None: + # seed everything for reproducibility + torch.manual_seed(args.seed) + np.random.seed(args.seed) + + # convert input hash size to num_embeddings if not using zch + if not args.use_zch: + args.input_hash_size = args.num_embeddings + + # setup environment + os.environ["RANK"] = str(rank) + if torch.cuda.is_available(): + device: torch.device = torch.device(f"cuda:{rank}") + backend = "nccl" + torch.cuda.set_device(device) + else: + device: torch.device = torch.device("cpu") + backend = "gloo" + dist.init_process_group(backend=backend, init_method="env://") + + # TEST FOR DATASET HASH + # train_dataloader = get_dataloader(args, backend, "train") + # for batch in train_dataloader: + # batch = batch.to(device) + # print("before hash", batch.sparse_features.to_dict()["cat_0"].values()[:5]) + # batch.sparse_features = hash_kjt(batch.sparse_features, args.num_embeddings) + # print("after hash", batch.sparse_features.to_dict()["cat_0"].values()[:5]) + # break + + # exit(0) + + # END TEST FOR DATASET HASH + + # get dataset + train_dataloader = get_dataloader(args, backend, "train") + val_dataloader = get_dataloader(args, backend, "val") + test_dataloader = get_dataloader(args, backend, "test") + + # create embedding configs + ebc_configs = [ + EmbeddingBagConfig( + name=f"t_{feature_name}", + embedding_dim=args.embedding_dim, + num_embeddings=( + none_throws(args.num_embeddings_per_feature)[feature_idx] + if args.num_embeddings is None + else args.num_embeddings + ), + feature_names=[feature_name], + ) + for feature_idx, feature_name in enumerate(DEFAULT_CAT_NAMES) + ] + + # get managed collision embedding bag collection + if args.use_zch: + ebc = ( + McEmbeddingBagCollectionAdapter( # TODO: add switch for other ZCH or no ZCH + tables=ebc_configs, + input_hash_size=args.input_hash_size, + device=torch.device("meta"), + world_size=get_local_size(), + use_mpzch=True, + mpzch_num_buckets=args.num_buckets, + ) + ) + else: + ebc = EmbeddingBagCollection(tables=ebc_configs, device=torch.device("meta")) + + # create model + dlrm_model = DLRM( + embedding_bag_collection=ebc, + dense_in_features=len(DEFAULT_INT_NAMES), + dense_arch_layer_sizes=[int(x) for x in args.dense_arch_layer_sizes.split(",")], + over_arch_layer_sizes=[int(x) for x in args.over_arch_layer_sizes.split(",")], + dense_device=device, + ) + + print(dlrm_model) + train_model = DLRMTrain(dlrm_model) + + # apply optimizer to the model + embedding_optimizer = torch.optim.Adagrad if args.adagrad else torch.optim.SGD + optimizer_kwargs = {"lr": args.learning_rate} + if args.adagrad: + optimizer_kwargs["eps"] = args.eps + apply_optimizer_in_backward( + embedding_optimizer, + train_model.model.sparse_arch.embedding_bag_collection.parameters(), + optimizer_kwargs, + ) + + # shard the model + planner = EmbeddingShardingPlanner( + topology=Topology( + local_world_size=get_local_size(), + world_size=dist.get_world_size(), + compute_device=device.type, + ), + batch_size=args.batch_size, + # If experience OOM, increase the percentage. see + # https://pytorch.org/torchrec/torchrec.distributed.planner.html#torchrec.distributed.planner.storage_reservations.HeuristicalStorageReservation + storage_reservation=HeuristicalStorageReservation(percentage=0.05), + ) + + sharders = get_default_sharders() + sharders.append(cast(ModuleSharder[nn.Module], ManagedCollisionCollectionSharder())) + + plan = planner.collective_plan(train_model, sharders, dist.GroupMember.WORLD) + + model = DistributedModelParallel( + module=train_model, + device=device, + plan=plan, + ) + + collision_remapping_tensor_dict = ( + {} + ) # feature_name: collision_tensor filled with all -1s with num_embedding size at the beginning, used only for non-zch case + benchmark_probe = None + if args.use_zch: + benchmark_probe = BenchmarkMCProbe( + mcec=model._dmp_wrapped_module.module.model.sparse_arch.embedding_bag_collection.mc_embedding_bag_collection._managed_collision_collection._managed_collision_modules, + mc_method="mpzch", + rank=rank, + ) + + interval_num_batches_show_qps = 50 + + total_time_in_training = 0 + total_num_queries_in_training = 0 + + # train the model + for epoch_idx in range(args.epochs): + model.train() + starter_list = [] + ender_list = [] + num_queries_per_batch_list = [] + pbar = tqdm(train_dataloader, desc=f"Epoch {epoch_idx}") + for batch_idx, batch in enumerate(pbar): + batch = batch.to(device) + starter, ender = torch.cuda.Event(enable_timing=True), torch.cuda.Event( + enable_timing=True + ) + if args.use_zch: + benchmark_probe.record_mcec_state(stage="before_fwd") + # forward pass + starter.record() + loss, outputs = model(batch) + ender.record() + loss.backward() + # do statistics + num_queries_per_batch = len(batch.labels) + starter_list.append(starter) + ender_list.append(ender) + num_queries_per_batch_list.append(num_queries_per_batch) + if args.use_zch: + benchmark_probe.record_mcec_state(stage="after_fwd") + # update zch statistics + benchmark_probe.update() + # push the zch stats to the queue + msg_content = { + "epoch_idx": epoch_idx, + "batch_idx": batch_idx, + "rank": rank, + "mch_stats": benchmark_probe.get_mch_stats(), + } + queue.put( + ("mch_stats", msg_content), + ) + if batch_idx % interval_num_batches_show_qps == 0 or batch_idx == len( + train_dataloader + ): + if batch_idx == 0: + # skip the first batch since it is not a full batch + continue + # synchronize all the threads to get the exact number of batches + torch.cuda.synchronize() + # calculate the qps + # NOTE: why do this qps calculation every interval_num_batches_show_qps batches? + # because performing this calculation needs to synchronize all the ranks by calling torch.cuda.synchronize() + # and this is a heavy operation (takes several milliseconds). So we only do this calculation every + # interval_num_batches_show_qps batches to reduce the overhead. + ## get per batch time list by calculating the time difference between the start and end events of each batch + per_batch_time_list = [] + for i in range(interval_num_batches_show_qps): + per_batch_time_list.append( + starter_list[i].elapsed_time(ender_list[i]) / 1000 + ) # convert to seconds by dividing by 1000 + ## calculate the total time in the interval + total_time_in_interval = sum(per_batch_time_list) + ## calculate the total number of queries in the interval + total_num_queries_in_interval = sum(num_queries_per_batch_list) + ## fabricate the message and total_num_queries_in_interval to the queue + interval_start_batch_idx = ( + batch_idx - interval_num_batches_show_qps + ) # the start batch index of the interval + interval_end_batch_idx = ( + batch_idx # the end batch index of the interval + ) + ## fabricate the message content + msg_content = { + "epoch_idx": epoch_idx, + "rank": rank, + "interval_start_batch_idx": interval_start_batch_idx, + "interval_end_batch_idx": interval_end_batch_idx, + "per_batch_time_list": per_batch_time_list, + "per_batch_num_queries_list": num_queries_per_batch_list, + } + ## put the message into the queue + queue.put(("duration_and_num_queries", msg_content)) + qps_per_interval = ( + total_num_queries_in_interval / total_time_in_interval + ) + total_time_in_training += total_time_in_interval + total_num_queries_in_training += total_num_queries_in_interval + pbar.set_postfix( + { + "QPS": qps_per_interval, + } + ) + pbar.update(interval_num_batches_show_qps) + # reset the lists + starter_list = [] + ender_list = [] + num_queries_per_batch_list = [] + # if batch_idx > 2: + # time.sleep(5) + # queue.put(("finished", {"rank": rank})) + # print("finished") + # exit(0) + # after each epoch, do validation + eval_result_dict = evaluation(model, val_dataloader, device) + # print the evaluation result + print(f"Epoch {epoch_idx} validation result: {eval_result_dict}") + # send the evaluation result to the queue + msg_content = { + "epoch_idx": epoch_idx, + "rank": rank, + "eval_result_dict": eval_result_dict, + } + queue.put(("eval_result", msg_content)) + + time.sleep(30) + queue.put(("finished", {"rank": rank})) + print("finished") + return + + # print("Total time in training: ", total_time_in_training) + # print("Total number of queries in training: ", total_num_queries_in_training) + # print("Average QPS: ", total_num_queries_in_training / total_time_in_training) + + +def evaluation(model: DLRMTrain, data_loader: DataLoader, device: torch.device): + """ + Evaluate the model on the given data loader. + """ + model.eval() + auroc = torchmetrics.AUROC(task="multiclass", num_classes=2).to(device) + log_loss_list = [] + label_val_sums = 0 + num_labels = 0 + for batch in tqdm(data_loader): + batch = batch.to(device) + with torch.no_grad(): + loss, outputs = model(batch) + loss_val, logits, labels = outputs + preds = torch.sigmoid(logits) + preds_reshaped = torch.stack((1 - preds, preds), dim=1) + auroc.update(preds_reshaped, labels) + # calculate log loss + batch_log_loss_list = -( + (1 + labels) / 2 * torch.log(preds) + + (1 - labels) / 2 * torch.log(1 - preds) + ) + log_loss_list.extend(batch_log_loss_list.tolist()) + label_val_sums += labels.sum().item() + num_labels += labels.shape[0] + auroc_result = auroc.compute().item() + # calculate ne as mean(log_loss_list) / log_loss(avg_label) + avg_label = label_val_sums / num_labels + avg_label = torch.tensor(avg_label).to(device) + avg_label_log_loss = -( + avg_label * torch.log(avg_label) + (1 - avg_label) * torch.log(1 - avg_label) + ) + ne = torch.mean(torch.tensor(log_loss_list)).item() / avg_label_log_loss.item() + print(f"AUROC: {auroc_result}, NE: {ne}") + eval_result_dict = { + "auroc": auroc_result, + "ne": ne, + } + return eval_result_dict + + +def statistic(args: argparse.Namespace, queue: multiprocessing.Queue): + """ + The process to perform statistic calculations + """ + mch_buffer = ( + {} + ) # {epcoh_idx:{end_batch_idx: {rank: data_dict}}} where data dict is {metric_name: metric_value} + num_processed_batches = 0 # counter of the number of processed batches + world_size = int(os.environ["WORLD_SIZE"]) # world size + finished_counter = 0 # counter of the number of finished processes + + # create a profiling result folder + os.makedirs(args.profiling_result_folder, exist_ok=True) + # create a csv file to save the zch_metrics + if args.use_zch: + zch_metrics_file_path = os.path.join( + args.profiling_result_folder, "zch_metrics.csv" + ) + with open(zch_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "feature_name", + "hit_cnt", + "total_cnt", + "insert_cnt", + "collision_cnt", + "hit_rate", + "insert_rate", + "collision_rate", + "rank_total_cnt", + ] + ) + # create a csv file to save the qps_metrics + qps_metrics_file_path = os.path.join( + args.profiling_result_folder, "qps_metrics.csv" + ) + with open(qps_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "rank", + "num_queries", + "duration", + "qps", + ] + ) + # create a csv file to save the eval_metrics + eval_metrics_file_path = os.path.join( + args.profiling_result_folder, "eval_metrics.csv" + ) + with open(eval_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "rank", + "auroc", + "ne", + ] + ) + + while finished_counter < world_size: + try: + # get the data from the queue + msg_type, msg_content = queue.get( + timeout=0.5 + ) # data are put into the queue im the form of (msg_type, epoch_idx, batch_idx, rank, rank_data_dict) + except Exception as e: + # if the queue is empty, check if all the processes have finished + # if finished_counter >= world_size: + # print(f"All processes have finished. {finished_counter} / {world_size}") + # break + # else: + # continue # keep waiting for the queue to be filled + # if queue is empty, check if all the processes have finished + if finished_counter >= world_size: + print(f"All processes have finished. {finished_counter} / {world_size}") + break + else: + continue # keep waiting for the queue to be filled + # when getting the data, check if the data is from the last batch + if ( + msg_type == "finished" + ): # if the message type is "finished", the process has finished + rank = msg_content["rank"] + finished_counter += 1 + print(f"Process {rank} has finished. {finished_counter} / {world_size}") + continue + elif msg_type == "mch_stats": + if not args.use_zch: + continue + epoch_idx = msg_content["epoch_idx"] + batch_idx = msg_content["batch_idx"] + rank = msg_content["rank"] + rank_batch_mch_stats = msg_content["mch_stats"] + # other wise, aggregate the data into the buffer + if epoch_idx not in mch_buffer: + mch_buffer[epoch_idx] = {} + if batch_idx not in mch_buffer[epoch_idx]: + mch_buffer[epoch_idx][batch_idx] = {} + mch_buffer[epoch_idx][batch_idx][rank] = rank_batch_mch_stats + num_processed_batches += 1 + # check if we have all the data from all the ranks for a batch in an epoch + # if we have all the data, combine the data from all the ranks + if len(mch_buffer[epoch_idx][batch_idx]) == world_size: + # create a dictionary to store the statistics for each batch + batch_stats = ( + {} + ) # {feature_name: {hit_cnt: 0, total_cnt: 0, insert_cnt: 0, collision_cnt: 0}} + # combine the data from all the ranks + for mch_stats_rank_idx in mch_buffer[epoch_idx][batch_idx].keys(): + rank_batch_mch_stats = mch_buffer[epoch_idx][batch_idx][ + mch_stats_rank_idx + ] + # for each feature table in the mch stats information + for mch_stats_feature_name in rank_batch_mch_stats.keys(): + # create the dictionary for the feature table if not created + if mch_stats_feature_name not in batch_stats: + batch_stats[mch_stats_feature_name] = { + "hit_cnt": 0, + "total_cnt": 0, + "insert_cnt": 0, + "collision_cnt": 0, + "rank_total_cnt": {}, # dictionary of {rank_idx: num_quries_mapped_to_the_rank} + } + # aggregate the data from all the ranks + ## aggregate the hit count + batch_stats[mch_stats_feature_name][ + "hit_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["hit_cnt"] + ## aggregate the total count + batch_stats[mch_stats_feature_name][ + "total_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["total_cnt"] + ## aggregate the insert count + batch_stats[mch_stats_feature_name][ + "insert_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name]["insert_cnt"] + ## aggregate the collision count + batch_stats[mch_stats_feature_name][ + "collision_cnt" + ] += rank_batch_mch_stats[mch_stats_feature_name][ + "collision_cnt" + ] + ## for rank total count, get the data from the rank data dict + batch_stats[mch_stats_feature_name]["rank_total_cnt"][ + mch_stats_rank_idx + ] = rank_batch_mch_stats[mch_stats_feature_name][ + "rank_total_cnt" + ] + # clear the buffer for the batch + del mch_buffer[epoch_idx][batch_idx] + # save the zch statistics to a file + with open(zch_metrics_file_path, "a") as f: + writer = csv.writer(f) + for feature_name, stats in batch_stats.items(): + hit_rate = stats["hit_cnt"] / stats["total_cnt"] + insert_rate = stats["insert_cnt"] / stats["total_cnt"] + collision_rate = stats["collision_cnt"] / stats["total_cnt"] + rank_total_cnt = json.dumps(stats["rank_total_cnt"]) + writer.writerow( + [ + epoch_idx, + batch_idx, + feature_name, + stats["hit_cnt"], + stats["total_cnt"], + stats["insert_cnt"], + stats["collision_cnt"], + hit_rate, + insert_rate, + collision_rate, + rank_total_cnt, + ] + ) + elif msg_type == "duration_and_num_queries": + epoch_idx = msg_content["epoch_idx"] + rank = msg_content["rank"] + interval_start_batch_idx = msg_content["interval_start_batch_idx"] + interval_end_batch_idx = msg_content["interval_end_batch_idx"] + per_batch_time_list = msg_content["per_batch_time_list"] + per_batch_num_queries_list = msg_content["per_batch_num_queries_list"] + # save the qps statistics to a file + with open(qps_metrics_file_path, "a") as f: + writer = csv.writer(f) + for i in range(len(per_batch_time_list)): + writer.writerow( + [ + epoch_idx, + str(interval_end_batch_idx + i), + rank, + per_batch_num_queries_list[i], + per_batch_time_list[i], + ( + per_batch_num_queries_list[i] / per_batch_time_list[i] + if per_batch_time_list[i] > 0 + else 0 + ), + ] + ) + elif msg_type == "eval_result": + epoch_idx = msg_content["epoch_idx"] + rank = msg_content["rank"] + eval_result_dict = msg_content["eval_result_dict"] + # save the evaluation result to a file + with open(eval_metrics_file_path, "a") as f: + writer = csv.writer(f) + writer.writerow( + [ + epoch_idx, + rank, + eval_result_dict["auroc"], + eval_result_dict["ne"], + ] + ) + else: + # raise a warning if the message type is not recognized + print("Warning: Unknown message type") + continue + + +if __name__ == "__main__": + args = parse_args(sys.argv[1:]) + + # set environment variables + os.environ["MASTER_ADDR"] = str("localhost") + os.environ["MASTER_PORT"] = str(get_free_port()) + # set a multiprocessing context + ctx = multiprocessing.get_context("spawn") + # create a queue to communicate between processes + queue = ctx.Queue() + # create a process to perform statistic calculations + stat_process = ctx.Process( + target=statistic, args=(args, queue) + ) # create a process to perform statistic calculations + stat_process.start() + # create a process to perform benchmarking + train_processes = [] + for rank in range(int(os.environ["WORLD_SIZE"])): + p = ctx.Process( + target=main, + args=(rank, args, queue), + ) + p.start() + train_processes.append(p) + + # wait for the training processes to finish + for p in train_processes: + p.join() + # wait for the statistic process to finish + stat_process.join() diff --git a/torchrec/distributed/benchmark/benchmark_zch_utils.py b/torchrec/distributed/benchmark/benchmark_zch_utils.py new file mode 100644 index 000000000..7dedf7a36 --- /dev/null +++ b/torchrec/distributed/benchmark/benchmark_zch_utils.py @@ -0,0 +1,240 @@ +import copy +import json +import os +from typing import Dict + +import numpy as np + +import torch +import torch.nn as nn +from torchrec.modules.mc_embedding_modules import ManagedCollisionEmbeddingCollection +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + MCHManagedCollisionModule, +) + +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor + + +class BenchmarkMCProbe(nn.Module): + def __init__( + self, + mcec: Dict[str, ManagedCollisionEmbeddingCollection], + mc_method: str, # method for managing collisions, one of ["zch", "mpzch"] + rank: int, # rank of the current model shard + log_file_folder: str = "benchmark_logs", # folder to store the logging file + ) -> None: + super().__init__() + # self._mcec is a pointer to the mcec object passed in + self._mcec = mcec + # record the mc_method + self._mc_method = mc_method + # initialize the logging file handler + os.makedirs(log_file_folder, exist_ok=True) + self._log_file_path = os.path.join(log_file_folder, f"rank_{rank}.json") + self._rank = rank # record the rank of the current model shard + # get the output_offsets of the mcec + self.per_table_output_offsets = ( + {} + ) # dict of {table_name [str]: output_offsets [torch.Tensor]} TODO: find out relationship between table_name and feature_name + if self._mc_method == "mpzch": + for table_name, mcec_module in self._mcec.items(): + self.per_table_output_offsets[table_name] = ( + mcec_module._output_global_offset_tensor + ) + # create a dictionary to store the state of mcec modules + self.mcec_state = {} + # create a dictionary to store the statistics of mch modules + self._mch_stats = ( + {} + ) # dictionary of {table_name [str]: {metric_name [str]: metric_value [int]}} + + # record mcec state to file + def record_mcec_state(self, stage: str) -> None: + """ + record the state of mcec modules to the log file + The recorded state is a dictionary of + {{stage: {table_name: {metric_name: state}}}} + It only covers for the current batch + + params: + stage (str): before_fwd, after_fwd + return: + None + """ + # check if the stage in the desired options + assert stage in ( + "before_fwd", + "after_fwd", + ), f"stage {stage} is not supported, valid options are before_fwd, after_fwd" + # create a dictionary to store the state of mcec modules + if stage not in self.mcec_state: + self.mcec_state[stage] = {} # dict of {table_name: {metric_name: state}} + # if the stage is before_fwd, only record the remapping_table + # save the mcec table state for each embedding table + self.mcec_state[stage][ + "table_state" + ] = {} # dict of {table_name: {"remapping_table": state}} + for table_name, mc_module in self._mcec.items(): + self.mcec_state[stage]["table_state"][table_name] = {} + # + if self._mc_method == "zch": + self.mcec_state[stage]["table_state"][table_name][ + "remapping_table" + ] = mc_module._mch_sorted_raw_ids + # save t + elif self._mc_method == "mpzch": + self.mcec_state[stage]["table_state"][table_name]["remapping_table"] = ( + mc_module._hash_zch_identities.clone() + .to_dense() + .squeeze() + .cpu() + .numpy() + .tolist() + ) + else: + raise NotImplementedError( + f"mc method {self._mc_method} is not supported yet" + ) + # for before_fwd, we only need to record the remapping_table + if stage == "before_fwd": + return + # for after_fwd, we need to record the feature values + # check if the "before_fwd" stage is recorded + assert ( + "before_fwd" in self.mcec_state + ), "before_fwd stage is not recorded, please call record_mcec_state before calling record_mcec_state after_fwd" + # create the dirctionary to store the mcec feature values before forward + self.mcec_state["before_fwd"]["feature_values"] = {} + # create the dirctionary to store the mcec feature values after forward + self.mcec_state[stage]["feature_values"] = {} # dict of {table_name: state} + # save the mcec feature values for each embedding table + for table_name, mc_module in self._mcec.items(): + # record the remapped feature values + if self._mc_method == "mpzch": # when using mpzch mc modules + # record the remapped feature values first + self.mcec_state[stage]["feature_values"][table_name] = ( + mc_module.table_name_on_device_remapped_ids_dict[table_name] + .cpu() + .numpy() + .tolist() + ) + # record the input feature values + self.mcec_state["before_fwd"]["feature_values"][table_name] = ( + mc_module.table_name_on_device_input_ids_dict[table_name] + .cpu() + .numpy() + .tolist() + ) + # check if the input feature values list is empty + if ( + len(self.mcec_state["before_fwd"]["feature_values"][table_name]) + == 0 + ): + # if the input feature values list is empty, make it a list of -2 with the same length as the remapped feature values + self.mcec_state["before_fwd"]["feature_values"][table_name] = [ + -2 + ] * len(self.mcec_state[stage]["feature_values"][table_name]) + else: # when using other zch mc modules # TODO: implement the feature value recording for zch + raise NotImplementedError( + f"zc method {self._mc_method} is not supported yet" + ) + return + + def get_mcec_state(self) -> Dict[str, Dict[str, Dict[str, Dict[str, int]]]]: + """ + get the state of mcec modules + the state is a dictionary of + {{stage: {table_name: {data_name: state}}}} + """ + return self.mcec_state + + def save_mcec_state(self) -> None: + """ + save the state of mcec modules to the log file + """ + with open(self._log_file_path, "w") as f: + json.dump(self.mcec_state, f, indent=4) + + def get_mch_stats(self) -> Dict[str, Dict[str, int]]: + """ + get the statistics of mch modules + the statistics is a dictionary of + {{table_name: {metric_name: metric_value}}} + """ + return self._mch_stats + + def update(self) -> None: + """ + Update the ZCH statistics for the current batch + Params: + None + Return: + None + Require: + self.mcec_state is not None and has recorded both "before_fwd" and "after_fwd" for a batch + Update: + self._mch_stats + """ + # create a dictionary to store the statistics for each batch + batch_stats = ( + {} + ) # table_name: {hit_cnt: 0, total_cnt: 0, insert_cnt: 0, collision_cnt: 0} + # calculate the statistics for each rank + # get the remapping id table before forward pass and the input feature values + rank_feature_value_before_fwd = self.mcec_state["before_fwd"]["feature_values"] + # get the remapping id table after forward pass and the remapped feature ids + rank_feature_value_after_fwd = self.mcec_state["after_fwd"]["feature_values"] + # for each feature table in the remapped information + for ( + feature_name, + remapped_feature_ids, + ) in rank_feature_value_after_fwd.items(): + # create a new diction for the feature table if not created + if feature_name not in batch_stats: + batch_stats[feature_name] = { + "hit_cnt": 0, + "total_cnt": 0, + "insert_cnt": 0, + "collision_cnt": 0, + "rank_total_cnt": 0, + } + # get the input faeture values + input_feature_values = np.array(rank_feature_value_before_fwd[feature_name]) + # get the values stored in the remapping table for each remapped feature id after forward pass + prev_remapped_values = np.array( + self.mcec_state["before_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + )[remapped_feature_ids] + # get the values stored in the remapping table for each remapped feature id before forward pass + after_remapped_values = np.array( + self.mcec_state["after_fwd"]["table_state"][f"{feature_name}"][ + "remapping_table" + ] + )[remapped_feature_ids] + # count the number of same values in prev_remapped_values and after_remapped_values + # hit count = number of remapped values that exist in the remapping table before forward pass + this_rank_hits_count = np.sum(prev_remapped_values == input_feature_values) + batch_stats[feature_name]["hit_cnt"] += int(this_rank_hits_count) + # count the number of insertions + ## insert count = the decreased number of empty slots in the remapping table + ## before and after forward pass + this_rank_insert_count = np.sum(prev_remapped_values == -1) - np.sum( + after_remapped_values == -1 + ) + batch_stats[feature_name]["insert_cnt"] += int(this_rank_insert_count) + # count the number of total values + ## total count = the number of remapped values in the remapping table after forward pass + this_rank_total_count = int(len(remapped_feature_ids)) + # count the number of values redirected to the rank + batch_stats[feature_name]["rank_total_cnt"] = this_rank_total_count + batch_stats[feature_name]["total_cnt"] += this_rank_total_count + # count the number of collisions + # collision count = total count - hit count - insert count + this_rank_collision_count = ( + this_rank_total_count - this_rank_hits_count - this_rank_insert_count + ) + batch_stats[feature_name]["collision_cnt"] += int(this_rank_collision_count) + self._mch_stats = batch_stats diff --git a/torchrec/distributed/benchmark/count_non_zch_collision.py b/torchrec/distributed/benchmark/count_non_zch_collision.py new file mode 100644 index 000000000..f70677279 --- /dev/null +++ b/torchrec/distributed/benchmark/count_non_zch_collision.py @@ -0,0 +1,189 @@ +import csv +import json +import multiprocessing +import os +import sys + +import numpy as np + +import torch +from benchmark_zch_dlrmv2 import parse_args +from data.dlrm_dataloader import get_dataloader +from torch import distributed as dist +from torchrec.test_utils import get_free_port +from tqdm import tqdm + + +def main(rank, args): + # seed everything for reproducibility + torch.manual_seed(args.seed) + np.random.seed(args.seed) + # setup environment + os.environ["RANK"] = str(rank) + if torch.cuda.is_available(): + device: torch.device = torch.device(f"cuda:{rank}") + backend = "nccl" + torch.cuda.set_device(device) + else: + device: torch.device = torch.device("cpu") + backend = "gloo" + dist.init_process_group(backend=backend, init_method="env://") + + train_dataloader = get_dataloader(args, backend, "train") + + # make folder to save the collision dict + os.makedirs(args.profiling_result_folder, exist_ok=True) + + # collision dict + collison_dict = {} # feature_name: {remapped_id: original_id} + collision_stat = {} # feature_name: {hit: 0, collision: 0, total: 0} + hash_value_lookup_table = ( + {} + ) # feature_name: {original_id: remapped_id} # used to look up the remapped id for the original id to save the time of hashing the original id again + remapping_tensor_dict = {} # feature_name: remapping_tensor + zch_metrics_file_path = os.path.join( + args.profiling_result_folder, "zch_metrics.csv" + ) + with open(zch_metrics_file_path, "w") as f: + writer = csv.writer(f) + writer.writerow( + [ + "epoch_idx", + "batch_idx", + "feature_name", + "hit_cnt", + "total_cnt", + "insert_cnt", + "collision_cnt", + "hit_rate", + "insert_rate", + "collision_rate", + "rank_idx", + ] + ) + + pbar = tqdm(train_dataloader, desc=f"Rank {rank}") + for batch_idx, batch in enumerate(pbar): + batch = batch.to(device) + for feature_name, feature_values_jt in batch.sparse_features.to_dict().items(): + if feature_name not in collison_dict: + collison_dict[feature_name] = {} + if feature_name not in collision_stat: + collision_stat[feature_name] = { + "hit_cnt": 0, + "collision_cnt": 0, + "total_cnt": 0, + "insert_cnt": 0, + } + if feature_name not in remapping_tensor_dict: + remapping_tensor_dict[feature_name] = ( + torch.zeros(args.num_embeddings, dtype=torch.int64) - 1 + ).to( + device + ) # create a tensor of size [num_embeddings] and initialize it with -1 + num_empty_slots_before_remapping = ( + torch.sum(remapping_tensor_dict[feature_name] == -1).cpu().item() + ) # count the number of empty slots in the remapping tensor + if feature_name not in hash_value_lookup_table: + hash_value_lookup_table[feature_name] = {} + # create progress bar of feature values + remapped_tensor_values = torch.zeros_like(feature_values_jt.values()) + input_feature_values = feature_values_jt.values() + for feature_value_idx in range(len(input_feature_values)): + feature_value = input_feature_values[feature_value_idx] + if feature_value.cpu().item() in hash_value_lookup_table[feature_name]: + hashed_feature_value = hash_value_lookup_table[feature_name][ + feature_value.cpu().item() + ] + else: + feature_value = feature_value.unsqueeze(0) # convert to [1, ] + feature_value = feature_value.to(torch.uint64) # convert to uint64 + hashed_feature_value = torch.ops.fbgemm.murmur_hash3( + feature_value, 0, 0 + ) + # convert to int64 + hashed_feature_value = hashed_feature_value.to( + torch.int64 + ) # convert to int64 + # convert to [0, num_embeddings) + hashed_feature_value = ( + (hashed_feature_value % args.num_embeddings).cpu().item() + ) # convert to [0, num_embeddings) + # save the hashed feature value to the lookup table + hash_value_lookup_table[feature_name][ + feature_value.cpu().item() + ] = hashed_feature_value + remapped_tensor_values[feature_value_idx] = hashed_feature_value + # check if the remapping_tensor_dict at remapped_value's indexed slot value is -1 + if remapping_tensor_dict[feature_name][hashed_feature_value] == -1: + # if the remapping_tensor_dict at remapped_value's indexed slot value is -1, update the remapping_tensor_dict at remapped_value's indexed slot value to feature_value + remapping_tensor_dict[feature_name][ + hashed_feature_value + ] = feature_value + # check if the hashed feature value is in the collision dict + num_empty_slots_after_remapping = ( + torch.sum(remapping_tensor_dict[feature_name] == -1).cpu().item() + ) # count the number of empty slots in the remapping tensor + insert_cnt = ( + num_empty_slots_before_remapping - num_empty_slots_after_remapping + ) + hit_cnt = ( + ( + torch.sum( + torch.eq( + input_feature_values, + remapping_tensor_dict[feature_name][remapped_tensor_values], + ) + ) + - insert_cnt + ) + .cpu() + .item() + ) + total_cnt = len(input_feature_values) + collision_cnt = total_cnt - hit_cnt - insert_cnt + collision_stat[feature_name]["hit_cnt"] = hit_cnt + collision_stat[feature_name]["collision_cnt"] = collision_cnt + collision_stat[feature_name]["total_cnt"] = total_cnt + collision_stat[feature_name]["insert_cnt"] = insert_cnt + + # save the collision stat + with open(zch_metrics_file_path, "a") as f: + writer = csv.writer(f) + for feature_name, stats in collision_stat.items(): + hit_rate = stats["hit_cnt"] / stats["total_cnt"] + insert_rate = stats["insert_cnt"] / stats["total_cnt"] + collision_rate = stats["collision_cnt"] / stats["total_cnt"] + writer.writerow( + [ + 0, + batch_idx, + feature_name, + stats["hit_cnt"], + stats["total_cnt"], + stats["insert_cnt"], + stats["collision_cnt"], + hit_rate, + insert_rate, + collision_rate, + rank, + ] + ) + + +if __name__ == "__main__": + args = parse_args(sys.argv[1:]) + # set environment variables + os.environ["MASTER_ADDR"] = str("localhost") + os.environ["MASTER_PORT"] = str(get_free_port()) + # set a multiprocessing context + ctx = multiprocessing.get_context("spawn") + # create a process to perform benchmarking + processes = [] + for rank in range(int(os.environ["WORLD_SIZE"])): + p = ctx.Process( + target=main, + args=(rank, args), + ) + p.start() + processes.append(p) diff --git a/torchrec/distributed/benchmark/data/__init__.py b/torchrec/distributed/benchmark/data/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/torchrec/distributed/benchmark/data/dlrm_dataloader.py b/torchrec/distributed/benchmark/data/dlrm_dataloader.py new file mode 100644 index 000000000..dc7c8b39f --- /dev/null +++ b/torchrec/distributed/benchmark/data/dlrm_dataloader.py @@ -0,0 +1,169 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import argparse +import os +from typing import List + +from torch import distributed as dist +from torch.utils.data import DataLoader +from torchrec.datasets.criteo import ( + CAT_FEATURE_COUNT, + DAYS, + DEFAULT_CAT_NAMES, + DEFAULT_INT_NAMES, + InMemoryBinaryCriteoIterDataPipe, +) +from torchrec.datasets.random import RandomRecDataset + +# OSS import +try: + # pyre-ignore[21] + # @manual=torchrec/distributed/benchmark/data:multi_hot_criteo + from data.multi_hot_criteo import MultiHotCriteoIterDataPipe + +except ImportError: + pass + +# internal import +try: + from .multi_hot_criteo import MultiHotCriteoIterDataPipe # noqa F811 +except ImportError: + pass + +STAGES = ["train", "val", "test"] + + +def _get_random_dataloader( + args: argparse.Namespace, + stage: str, +) -> DataLoader: + attr = f"limit_{stage}_batches" + num_batches = getattr(args, attr) + if stage in ["val", "test"] and args.test_batch_size is not None: + batch_size = args.test_batch_size + else: + batch_size = args.batch_size + return DataLoader( + RandomRecDataset( + keys=DEFAULT_CAT_NAMES, + batch_size=batch_size, + hash_size=args.num_embeddings, + hash_sizes=( + args.num_embeddings_per_feature + if hasattr(args, "num_embeddings_per_feature") + else None + ), + manual_seed=getattr(args, "seed", None), + ids_per_feature=1, + num_dense=len(DEFAULT_INT_NAMES), + num_batches=num_batches, + ), + batch_size=None, + batch_sampler=None, + pin_memory=args.pin_memory, + num_workers=0, + ) + + +def _get_in_memory_dataloader( + args: argparse.Namespace, + stage: str, +) -> DataLoader: + if args.in_memory_binary_criteo_path is not None: + dir_path = args.in_memory_binary_criteo_path + sparse_part = "sparse.npy" + datapipe = InMemoryBinaryCriteoIterDataPipe + else: + dir_path = args.synthetic_multi_hot_criteo_path + sparse_part = "sparse_multi_hot.npz" + datapipe = MultiHotCriteoIterDataPipe + + if args.dataset_name == "criteo_kaggle": + # criteo_kaggle has no validation set, so use 2nd half of training set for now. + # Setting stage to "test" will get the 2nd half of the dataset. + # Setting root_name to "train" reads from the training set file. + (root_name, stage) = ( + ("train", "train") if stage == "train" else ("train", "test") + ) + stage_files: List[List[str]] = [ + [os.path.join(dir_path, f"{root_name}_dense.npy")], + [os.path.join(dir_path, f"{root_name}_{sparse_part}")], + [os.path.join(dir_path, f"{root_name}_labels.npy")], + ] + # criteo_1tb code path uses below two conditionals + elif stage == "train": + stage_files: List[List[str]] = [ + [os.path.join(dir_path, f"day_{i}_dense.npy") for i in range(DAYS - 1)], + [os.path.join(dir_path, f"day_{i}_{sparse_part}") for i in range(DAYS - 1)], + [os.path.join(dir_path, f"day_{i}_labels.npy") for i in range(DAYS - 1)], + ] + elif stage in ["val", "test"]: + stage_files: List[List[str]] = [ + [os.path.join(dir_path, f"day_{DAYS-1}_dense.npy")], + [os.path.join(dir_path, f"day_{DAYS-1}_{sparse_part}")], + [os.path.join(dir_path, f"day_{DAYS-1}_labels.npy")], + ] + if stage in ["val", "test"] and args.test_batch_size is not None: + batch_size = args.test_batch_size + else: + batch_size = args.batch_size + dataloader = DataLoader( + datapipe( + stage, + *stage_files, # pyre-ignore[6] + batch_size=batch_size, + rank=dist.get_rank(), + world_size=dist.get_world_size(), + drop_last=args.drop_last_training_batch if stage == "train" else False, + shuffle_batches=args.shuffle_batches, + shuffle_training_set=args.shuffle_training_set, + shuffle_training_set_random_seed=args.seed, + mmap_mode=args.mmap_mode, + hashes=( + [args.num_embeddings] * CAT_FEATURE_COUNT + if args.input_hash_size is None + else ([args.input_hash_size] * CAT_FEATURE_COUNT) + ), + ), + batch_size=None, + pin_memory=args.pin_memory, + collate_fn=lambda x: x, + ) + return dataloader + + +def get_dataloader(args: argparse.Namespace, backend: str, stage: str) -> DataLoader: + """ + Gets desired dataloader from dlrm_main command line options. Currently, this + function is able to return either a DataLoader wrapped around a RandomRecDataset or + a Dataloader wrapped around an InMemoryBinaryCriteoIterDataPipe. + + Args: + args (argparse.Namespace): Command line options supplied to dlrm_main.py's main + function. + backend (str): "nccl" or "gloo". + stage (str): "train", "val", or "test". + + Returns: + dataloader (DataLoader): PyTorch dataloader for the specified options. + + """ + stage = stage.lower() + if stage not in STAGES: + raise ValueError(f"Supplied stage was {stage}. Must be one of {STAGES}.") + + args.pin_memory = ( + (backend == "nccl") if not hasattr(args, "pin_memory") else args.pin_memory + ) + + if ( + args.in_memory_binary_criteo_path is None + and args.synthetic_multi_hot_criteo_path is None + ): + return _get_random_dataloader(args, stage) + else: + return _get_in_memory_dataloader(args, stage) diff --git a/torchrec/distributed/benchmark/data/multi_hot_criteo.py b/torchrec/distributed/benchmark/data/multi_hot_criteo.py new file mode 100644 index 000000000..e6126290c --- /dev/null +++ b/torchrec/distributed/benchmark/data/multi_hot_criteo.py @@ -0,0 +1,306 @@ +#!/usr/bin/env python3 +# Copyright (c) Meta Platforms, Inc. and affiliates. +# +# This source code is licensed under the MIT license found in the +# LICENSE file in the root directory of this source tree. + +import zipfile +from typing import Dict, Iterator, List, Optional + +import numpy as np +import torch +from iopath.common.file_io import PathManager, PathManagerFactory +from pyre_extensions import none_throws +from torch.utils.data import IterableDataset +from torchrec.datasets.criteo import CAT_FEATURE_COUNT, DEFAULT_CAT_NAMES +from torchrec.datasets.utils import Batch, PATH_MANAGER_KEY +from torchrec.sparse.jagged_tensor import KeyedJaggedTensor + + +class MultiHotCriteoIterDataPipe(IterableDataset): + """ + Datapipe designed to operate over the MLPerf DLRM v2 synthetic multi-hot dataset. + This dataset can be created by following the steps in + torchrec_dlrm/scripts/materialize_synthetic_multihot_dataset.py. + Each rank reads only the data for the portion of the dataset it is responsible for. + + Args: + stage (str): "train", "val", or "test". + dense_paths (List[str]): List of path strings to dense npy files. + sparse_paths (List[str]): List of path strings to multi-hot sparse npz files. + labels_paths (List[str]): List of path strings to labels npy files. + batch_size (int): batch size. + rank (int): rank. + world_size (int): world size. + drop_last (Optional[bool]): Whether to drop the last batch if it is incomplete. + shuffle_batches (bool): Whether to shuffle batches + shuffle_training_set (bool): Whether to shuffle all samples in the dataset. + shuffle_training_set_random_seed (int): The random generator seed used when + shuffling the training set. + hashes (Optional[int]): List of max categorical feature value for each feature. + Length of this list should be CAT_FEATURE_COUNT. + path_manager_key (str): Path manager key used to load from different + filesystems. + + Example:: + + datapipe = MultiHotCriteoIterDataPipe( + dense_paths=["day_0_dense.npy"], + sparse_paths=["day_0_sparse_multi_hot.npz"], + labels_paths=["day_0_labels.npy"], + batch_size=1024, + rank=torch.distributed.get_rank(), + world_size=torch.distributed.get_world_size(), + ) + batch = next(iter(datapipe)) + """ + + def __init__( + self, + stage: str, + dense_paths: List[str], + sparse_paths: List[str], + labels_paths: List[str], + batch_size: int, + rank: int, + world_size: int, + drop_last: Optional[bool] = False, + shuffle_batches: bool = False, + shuffle_training_set: bool = False, + shuffle_training_set_random_seed: int = 0, + mmap_mode: bool = False, + hashes: Optional[List[int]] = None, + path_manager_key: str = PATH_MANAGER_KEY, + ) -> None: + self.stage = stage + self.dense_paths = dense_paths + self.sparse_paths = sparse_paths + self.labels_paths = labels_paths + self.batch_size = batch_size + self.rank = rank + self.world_size = world_size + self.drop_last = drop_last + self.shuffle_batches = shuffle_batches + self.shuffle_training_set = shuffle_training_set + np.random.seed(shuffle_training_set_random_seed) + self.mmap_mode = mmap_mode + # hashes are not used because they were already applied in the + # script that generates the multi-hot dataset. + self.hashes: np.ndarray = np.array(hashes).reshape((CAT_FEATURE_COUNT, 1)) + self.path_manager_key = path_manager_key + self.path_manager: PathManager = PathManagerFactory().get(path_manager_key) + + if shuffle_training_set and stage == "train": + # Currently not implemented for the materialized multi-hot dataset. + self._shuffle_and_load_data_for_rank() + else: + m = "r" if mmap_mode else None + self.dense_arrs: List[np.ndarray] = [ + np.load(f, mmap_mode=m) for f in self.dense_paths + ] + self.labels_arrs: List[np.ndarray] = [ + np.load(f, mmap_mode=m) for f in self.labels_paths + ] + self.sparse_arrs: List = [] + for sparse_path in self.sparse_paths: + multi_hot_ids_l = [] + for feat_id_num in range(CAT_FEATURE_COUNT): + multi_hot_ft_ids = self._load_from_npz( + sparse_path, f"{feat_id_num}.npy" + ) + multi_hot_ids_l.append(multi_hot_ft_ids) + self.sparse_arrs.append(multi_hot_ids_l) + len_d0 = len(self.dense_arrs[0]) + second_half_start_index = int(len_d0 // 2 + len_d0 % 2) + if stage == "val": + self.dense_arrs[0] = self.dense_arrs[0][:second_half_start_index, :] + self.labels_arrs[0] = self.labels_arrs[0][:second_half_start_index, :] + self.sparse_arrs[0] = [ + feats[:second_half_start_index, :] for feats in self.sparse_arrs[0] + ] + elif stage == "test": + self.dense_arrs[0] = self.dense_arrs[0][second_half_start_index:, :] + self.labels_arrs[0] = self.labels_arrs[0][second_half_start_index:, :] + self.sparse_arrs[0] = [ + feats[second_half_start_index:, :] for feats in self.sparse_arrs[0] + ] + # When mmap_mode is enabled, sparse features are hashed when + # samples are batched in def __iter__. Otherwise, the dataset has been + # preloaded with sparse features hashed in the preload stage, here: + # if not self.mmap_mode and self.hashes is not None: + # for k, _ in enumerate(self.sparse_arrs): + # self.sparse_arrs[k] = [ + # feat % hash + # for (feat, hash) in zip(self.sparse_arrs[k], self.hashes) + # ] + + self.num_rows_per_file: List[int] = list(map(len, self.dense_arrs)) + total_rows = sum(self.num_rows_per_file) + self.num_full_batches: int = ( + total_rows // batch_size // self.world_size * self.world_size + ) + self.last_batch_sizes: np.ndarray = np.array( + [0 for _ in range(self.world_size)] + ) + remainder = total_rows % (self.world_size * batch_size) + if not self.drop_last and 0 < remainder: + if remainder < self.world_size: + self.num_full_batches -= self.world_size + self.last_batch_sizes += batch_size + else: + self.last_batch_sizes += remainder // self.world_size + self.last_batch_sizes[: remainder % self.world_size] += 1 + + self.multi_hot_sizes: List[int] = [ + multi_hot_feat.shape[-1] for multi_hot_feat in self.sparse_arrs[0] + ] + + # These values are the same for the KeyedJaggedTensors in all batches, so they + # are computed once here. This avoids extra work from the KeyedJaggedTensor sync + # functions. + self.keys: List[str] = DEFAULT_CAT_NAMES + self.index_per_key: Dict[str, int] = { + key: i for (i, key) in enumerate(self.keys) + } + + def _load_from_npz(self, fname, npy_name): + # figure out offset of .npy in .npz + zf = zipfile.ZipFile(fname) + info = zf.NameToInfo[npy_name] + assert info.compress_type == 0 + zf.fp.seek(info.header_offset + len(info.FileHeader()) + 20) + # read .npy header + zf.open(npy_name, "r") + version = np.lib.format.read_magic(zf.fp) + shape, fortran_order, dtype = np.lib.format._read_array_header(zf.fp, version) + assert ( + dtype == "int32" + ), f"sparse multi-hot dtype is {dtype} but should be int32" + offset = zf.fp.tell() + # create memmap + return np.memmap( + zf.filename, + dtype=dtype, + shape=shape, + order="F" if fortran_order else "C", + mode="r", + offset=offset, + ) + + def _np_arrays_to_batch( + self, + dense: np.ndarray, + sparse: List[np.ndarray], + labels: np.ndarray, + ) -> Batch: + if self.shuffle_batches: + # Shuffle all 3 in unison + shuffler = np.random.permutation(len(dense)) + sparse = [multi_hot_ft[shuffler, :] for multi_hot_ft in sparse] + dense = dense[shuffler] + labels = labels[shuffler] + + batch_size = len(dense) + lengths = torch.ones((CAT_FEATURE_COUNT * batch_size), dtype=torch.int32) + for k, multi_hot_size in enumerate(self.multi_hot_sizes): + lengths[k * batch_size : (k + 1) * batch_size] = multi_hot_size + offsets = torch.cumsum(torch.concat((torch.tensor([0]), lengths)), dim=0) + length_per_key = [ + batch_size * multi_hot_size for multi_hot_size in self.multi_hot_sizes + ] + offset_per_key = torch.cumsum( + torch.concat((torch.tensor([0]), torch.tensor(length_per_key))), dim=0 + ) + values = torch.concat([torch.from_numpy(feat).flatten() for feat in sparse]) + return Batch( + dense_features=torch.from_numpy(dense.copy()), + sparse_features=KeyedJaggedTensor( + keys=self.keys, + values=values, + lengths=lengths, + offsets=offsets, + stride=batch_size, + length_per_key=length_per_key, + offset_per_key=offset_per_key.tolist(), + index_per_key=self.index_per_key, + ), + labels=torch.from_numpy(labels.reshape(-1).copy()), + ) + + def __iter__(self) -> Iterator[Batch]: + # Invariant: buffer never contains more than batch_size rows. + buffer: Optional[List[np.ndarray]] = None + + def append_to_buffer( + dense: np.ndarray, + sparse: List[np.ndarray], + labels: np.ndarray, + ) -> None: + nonlocal buffer + if buffer is None: + buffer = [dense, sparse, labels] + else: + buffer[0] = np.concatenate((buffer[0], dense)) + buffer[1] = [np.concatenate((b, s)) for b, s in zip(buffer[1], sparse)] + buffer[2] = np.concatenate((buffer[2], labels)) + + # Maintain a buffer that can contain up to batch_size rows. Fill buffer as + # much as possible on each iteration. Only return a new batch when batch_size + # rows are filled. + file_idx = 0 + row_idx = 0 + batch_idx = 0 + buffer_row_count = 0 + cur_batch_size = ( + self.batch_size if self.num_full_batches > 0 else self.last_batch_sizes[0] + ) + while ( + batch_idx + < self.num_full_batches + (self.last_batch_sizes[0] > 0) * self.world_size + ): + if buffer_row_count == cur_batch_size or file_idx == len(self.dense_arrs): + if batch_idx % self.world_size == self.rank: + yield self._np_arrays_to_batch(*none_throws(buffer)) + buffer = None + buffer_row_count = 0 + batch_idx += 1 + if 0 <= batch_idx - self.num_full_batches < self.world_size and ( + self.last_batch_sizes[0] > 0 + ): + cur_batch_size = self.last_batch_sizes[ + batch_idx - self.num_full_batches + ] + else: + rows_to_get = min( + cur_batch_size - buffer_row_count, + self.num_rows_per_file[file_idx] - row_idx, + ) + buffer_row_count += rows_to_get + slice_ = slice(row_idx, row_idx + rows_to_get) + + if batch_idx % self.world_size == self.rank: + dense_inputs = self.dense_arrs[file_idx][slice_, :] + sparse_inputs = [ + feats[slice_, :] for feats in self.sparse_arrs[file_idx] + ] + target_labels = self.labels_arrs[file_idx][slice_, :] + + # if self.mmap_mode and self.hashes is not None: + # sparse_inputs = [ + # feats % hash + # for (feats, hash) in zip(sparse_inputs, self.hashes) + # ] + + append_to_buffer( + dense_inputs, + sparse_inputs, + target_labels, + ) + row_idx += rows_to_get + + if row_idx >= self.num_rows_per_file[file_idx]: + file_idx += 1 + row_idx = 0 + + def __len__(self) -> int: + return self.num_full_batches // self.world_size + (self.last_batch_sizes[0] > 0) diff --git a/torchrec/modules/hash_mc_evictions.py b/torchrec/modules/hash_mc_evictions.py index c5875bf8d..415a4cd95 100644 --- a/torchrec/modules/hash_mc_evictions.py +++ b/torchrec/modules/hash_mc_evictions.py @@ -73,7 +73,10 @@ def gen_score(self, feature: JaggedTensor, device: torch.device) -> torch.Tensor return torch.full_like( feature.values(), # pyre-ignore [58] - self._config.single_ttl + int(time.time() / 3600), + self._config.single_ttl + + int( + time.time() / 3600 + ), # add the current time to the single_ttl, this is the time whem each value is expired and becomes evictable dtype=torch.int32, device=device, ) diff --git a/torchrec/modules/hash_mc_modules.py b/torchrec/modules/hash_mc_modules.py index fe5a0ce19..81eb3138b 100644 --- a/torchrec/modules/hash_mc_modules.py +++ b/torchrec/modules/hash_mc_modules.py @@ -322,6 +322,17 @@ def __init__( if self._is_inference is True: self.reset_inference_mode() + # create two dictionaries to store the input values and remapped ids on the current rank + # these values are used for calculating zch metrics like hit rate and collision rate + ## on-device remapped ids + self.table_name_on_device_remapped_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: on_device_remapped_ids} + ## on-device input ids + self.table_name_on_device_input_ids_dict: Dict[str, torch.Tensor] = ( + {} + ) # {table_name: input JT values that maps to the current rank} + logger.info( f"HashZchManagedCollisionModule: {self._name=}, {self.device=}, " f"{self._zch_size=}, {self._input_hash_size=}, {self._max_probe=}, " @@ -459,6 +470,9 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: values=values, output_offset=self._output_global_offset_tensor, ) + + self.table_name_on_device_input_ids_dict[name] = values.clone() + num_reserved_slots = self.get_reserved_slots_per_bucket() remapped_ids, evictions = torch.ops.fbgemm.zero_collision_hash( input=values, @@ -483,6 +497,9 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: opt_in_rands=opt_in_rands, ) + # record the on-device remapped ids + self.table_name_on_device_remapped_ids_dict[name] = remapped_ids.clone() + if self._scalar_logger is not None: assert identities_0 is not None self._scalar_logger.update( @@ -510,6 +527,9 @@ def remap(self, features: Dict[str, JaggedTensor]) -> Dict[str, JaggedTensor]: weights=feature.weights_or_none(), ) + # if name == "t_cat_0": + # print("remapped_feature", remapped_ids) + if self._scalar_logger is not None: self._scalar_logger( run_type="train" if self.training else "eval", diff --git a/torchrec/modules/mc_adapter.py b/torchrec/modules/mc_adapter.py new file mode 100644 index 000000000..fd971e389 --- /dev/null +++ b/torchrec/modules/mc_adapter.py @@ -0,0 +1,188 @@ +# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary. + +# pyre-strict +import sys +from typing import Dict, Iterator, List, Optional, Tuple + +import torch +import torch.nn as nn +from torch.nn.parameter import Parameter +from torchrec.modules.embedding_configs import EmbeddingBagConfig, EmbeddingConfig +from torchrec.modules.embedding_modules import ( + EmbeddingBagCollection, + EmbeddingCollection, +) +from torchrec.modules.hash_mc_evictions import ( + HashZchEvictionConfig, + HashZchEvictionPolicyName, +) +from torchrec.modules.hash_mc_modules import HashZchManagedCollisionModule +from torchrec.modules.mc_embedding_modules import ( + ManagedCollisionEmbeddingBagCollection, + ManagedCollisionEmbeddingCollection, +) +from torchrec.modules.mc_modules import ( + DistanceLFU_EvictionPolicy, + ManagedCollisionCollection, + MCHManagedCollisionModule, +) +from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor + + +class McEmbeddingCollectionAdapter(nn.Module): + """ + Managed Collision Embedding Collection Adapter + The adapter to convert exiting EmbeddingCollection to Managed Collision Embedding Collection module + The adapter will use the original EmbeddingCollection table but will pass input + """ + + def __init__( + self, + embedding_collection: EmbeddingCollection, + input_hash_size: int, + device: torch.device, + eviction_interval: int = 2, + allow_in_place_embed_weight_update: bool = False, + ) -> None: + """ + INIT_DOC_STRING + """ + super().__init__() + # build dictionary for {table_name: table_config} + mc_modules = {} + for table_name, table_config in embedding_collection.embedding_configs(): + mc_modules[table_name] = MCHManagedCollisionModule( + zch_size=table_config.num_embeddings, + device=device, + input_hash_size=input_hash_size, + eviction_interval=eviction_interval, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) + self.mc_embedding_collection = ManagedCollisionEmbeddingCollection( + embedding_collection=embedding_collection, + managed_collision_collection=ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=embedding_collection.embedding_configs(), + ), + allow_in_place_embed_weight_update=allow_in_place_embed_weight_update, + return_remapped_features=True, # not return remapped features + ) + self.remapped_ids = None # to store remapped ids + + def forward(self, input: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: + """ + Args: + input (KeyedJaggedTensor): KJT of form [F X B X L]. + Returns: + Dict[str, JaggedTensor]: dictionary of {'feature_name': JaggedTensor} + """ + mc_ec_out, remapped_ids = self.mc_embedding_collection(input) + self.remapped_ids = remapped_ids + return mc_ec_out[0] + + +class McEmbeddingBagCollectionAdapter(nn.Module): + """ + Managed Collision Embedding Collection Adapter + The adapter to convert exiting EmbeddingCollection to Managed Collision Embedding Collection module + The adapter will use the original EmbeddingCollection table but will pass input + """ + + def __init__( + self, + tables: List[EmbeddingBagConfig], + input_hash_size: int, + device: torch.device, + world_size: int, + eviction_interval: int = 1, + allow_in_place_embed_weight_update: bool = False, + use_mpzch: bool = False, + mpzch_num_buckets: Optional[int] = None, + ) -> None: + """ + Initialize an EmbeddingBagCollectionAdapter. + Parameters: + tables (List[EmbeddingBagConfig]): List of EmbeddingBagConfig. Should be the same as the original EmbeddingBagCollection. + input_hash_size (int): the upper bound of input feature values + device (torch.device): the device to use + world_size (int): the world size + eviction_interval (int): the eviction interval, default to 1 hour + allow_in_place_embed_weight_update (bool): whether to allow in-place embedding weight update + use_mpzch (bool): whether to use MPZCH or not # TODO: change this to a str to support different zch + mpzch_num_buckets (Optional[int]): the number of buckets for MPZCH # TODO: change this to a config dict to support different zch configs + """ + # super().__init__(tables=tables, device=device) + super().__init__() + # create ebc from table configs + ebc = EmbeddingBagCollection(tables=tables, device=torch.device("meta")) + # build dictionary for {table_name: table_config} + mc_modules = {} + for table_config in ebc.embedding_bag_configs(): + table_name = table_config.name + if use_mpzch: + # if use MPZCH, create a HashZchManagedCollisionModule + mc_modules[table_name] = HashZchManagedCollisionModule( # MPZCH + is_inference=False, + zch_size=(table_config.num_embeddings), + input_hash_size=input_hash_size, + device=device, + total_num_buckets=( + mpzch_num_buckets if mpzch_num_buckets else world_size + ), # total_num_buckets if not passed, use world_size, WORLD_SIZE should be a factor of total_num_buckets + eviction_policy_name=HashZchEvictionPolicyName.SINGLE_TTL_EVICTION, # defaultly using single ttl eviction policy + eviction_config=HashZchEvictionConfig( + features=table_config.feature_names, + single_ttl=eviction_interval, + ), + ) + else: # if not use MPZCH, create a MCHManagedCollisionModule using the sort ZCH algorithm + mc_modules[table_name] = MCHManagedCollisionModule( # sort ZCH + zch_size=table_config.num_embeddings, + device=device, + input_hash_size=input_hash_size, + eviction_interval=eviction_interval, + eviction_policy=DistanceLFU_EvictionPolicy(), + ) # NOTE: the benchmark for sort ZCH is not implemented yet + # TODO: add the pure hash module here + + # create the mcebc module with the mc modules and the original ebc + self.mc_embedding_bag_collection = ( + ManagedCollisionEmbeddingBagCollection( # ZCH or not + embedding_bag_collection=ebc, + managed_collision_collection=ManagedCollisionCollection( + managed_collision_modules=mc_modules, + embedding_configs=ebc.embedding_bag_configs(), + ), + allow_in_place_embed_weight_update=allow_in_place_embed_weight_update, + return_remapped_features=False, # not return remapped features + ) + ) + + def forward(self, input_kjt: KeyedJaggedTensor) -> Dict[str, JaggedTensor]: + """ + Args: + input (KeyedJaggedTensor): KJT of form [F X B X L]. + Returns: + Dict[str, JaggedTensor]: dictionary of {'feature_name': JaggedTensor} + """ + mc_ebc_out, per_table_remapped_id = self.mc_embedding_bag_collection(input_kjt) + return mc_ebc_out + + def parameters(self, recurse: bool = True) -> Iterator[Parameter]: + # only return the parameters of the original EmbeddingBagCollection, not _managed_collision_collection modules + return self.mc_embedding_bag_collection._embedding_module.parameters( + recurse=recurse + ) + + def embedding_bag_configs(self) -> List[EmbeddingConfig]: + """ + Returns: + Dict[str, EmbeddingConfig]: dictionary of {'feature_name': EmbeddingConfig} + """ + # pyre-ignore[16]: `ManagedCollisionEmbeddingBagCollection` has no attribute `_embedding_module` + return ( + self.mc_embedding_bag_collection._embedding_module.embedding_bag_configs() + ) + + def get_per_table_remapped_id(self) -> Dict[str, JaggedTensor]: + return self.per_table_remapped_id