class_docstr: CachedEmbeddingBag
  
  Cached Embedding. Apply a GPU-based software cache approaches to dynamically manage the embedding table in the CPU and GPU memory space.
  It can leverage the id's frequency statistics of the target dataset, by passing a frequency list to param `ids_freq_mapping`.
  You can also apply a naive LFU cache eviction strategy by setting `evict_strategy` as EvictionStrategy.LFU.
  
  Args:
      num_embeddings (int): size of the dictionary of embeddings
      embedding_dim (int):  the size of each embedding vector
      padding_idx (int, optional): If specified, the entries at padding_idx do not contribute to the gradient; therefore, the embedding vector at padding_idx is not updated during training, i.e. it remains as a fixed “pad”. For a newly constructed EmbeddingBag, the embedding vector at padding_idx will default to all zeros, but can be updated to another value to be used as the padding vector. Note that the embedding vector at padding_idx is excluded from the reduction.
      max_norm (float, optional): If given, each embedding vector with norm larger than max_norm is renormalized to have norm max_norm
      norm_type (str, optional): The p of the p-norm to compute for the max_norm option. Defaults to 2.
      scale_grad_by_freq (bool, optional): if given, this will scale gradients by the inverse of frequency of the words in the mini-batch. Default False. Note: this option is not supported when mode="max". Defaults to False.
      sparse (bool, optional): if True, gradient w.r.t. weight matrix will be a sparse tensor. See Notes for more details regarding sparse gradients. Note: this option is not supported when mode="max".. Defaults to False.
      _weight (torch.Tensor, optional): an embedding weight tensor. Concatenate multiple tables in a embedding bag as a single one. Defaults to None.
      mode (str, optional): "sum", "mean" or "max". Specifies the way to reduce the bag. "sum" computes the weighted sum, taking per_sample_weights into consideration. "mean" computes the average of the values in the bag, "max" computes the max value over each bag. Default: "mean". Defaults to 'mean'.
      include_last_offset (bool, optional): if True, offsets has one additional element, where the last element is equivalent to the size of indices. This matches the CSR format.. Defaults to False.
      dtype (torch.dtype, optional): data type of the cpu weight initialization. Defaults to None meaning float32.
      device (torch.device, optional): device type to the cpu weight. Defaults to None meaning cpu.
      cache_ratio (float, float): cache ratio of the #cuda_weight_row / #cpu_weight_row
      ids_freq_mapping (Union[List, torch.Tensor], optional): the frequency of each embedding vector occurs in dataset. Defaults to None.
      warmup_ratio (float, optional): the ratio of cuda cache is warmuped with. Defaults to 0.7.
      buffer_size (int, optional): the max number of vectors in transmitter buffer. If set to 0, the buffer is not used. Defaults to 0.
      pin_weight (bool, optional): pin the cpu weight. Defaults to False.
      evict_strategy (EvictionStrategy, optional): evict strategy of the software cache. Defaults to EvictionStrategy.DATASET.
code: def __init__(
      self,
      num_embeddings: int,
      embedding_dim: int,
      padding_idx: int = None,
      max_norm: float = None,
      norm_type: float = 2.0,
      scale_grad_by_freq: bool = False,
      sparse: bool = False,
      _weight: Optional[torch.Tensor] = None,
      mode: str = "mean",
      include_last_offset: bool = False,
      dtype: Optional[torch.dtype] = None,
      device: Optional[torch.device] = None,
      cache_ratio: float = 0.01,
      ids_freq_mapping: Optional[Union[List, torch.Tensor]] = None,
      warmup_ratio: float = 0.7,
      buffer_size: int = 0,
      pin_weight: bool = False,
      evict_strategy: EvictionStrategy = EvictionStrategy.LFU,
  ):
      super(CachedEmbeddingBag, self).__init__(
          num_embeddings,
          embedding_dim,
          padding_idx,
          max_norm,
          norm_type,
          scale_grad_by_freq,
          sparse,
          mode,
          include_last_offset,
      )
  
      assert (
          cache_ratio <= 1.0
      ), f"cache ratio {cache_ratio} must less than 1.0"
      self.evict_strategy = evict_strategy
      if _weight is None:
          _weight = self._weight_alloc(dtype, device)
      cuda_row_num = int(num_embeddings * cache_ratio)
      # configure weight & cache
      self._preprocess(
          _weight,
          cuda_row_num,
          ids_freq_mapping,
          warmup_ratio,
          buffer_size,
          pin_weight,
      )
      self.cache_op = True
  
imports: from typing import Iterator, List, Optional, Tuple, Union
  import torch
  import torch.nn.functional
  from torch.nn.parameter import Parameter
  from .base_embedding import BaseEmbeddingBag
  from .cache_mgr import CachedParamMgr, EvictionStrategy
label_desc: Use image node_id 1 to create a new CachedEmbeddingBag object from inherited base classes: BaseEmbeddingBag with example: obj = CachedEmbeddingBag(num_embeddings, embedding_dim, padding_idx, max_norm, norm_type, scale_grad_by_freq, sparse, _weight, mode, include_last_offset, dtype, device, cache_ratio, ids_freq_mapping, warmup_ratio, buffer_size, pin_weight, evict_strategy)