class_docstr: _BatchedFusedEmbeddingLookups is a thin wrapper we have around SplitTableBatchedEmbeddingBagsCodegen.
  This is not meant to be directly used. Instead use FusedEmbeddingBagCollection/FusedEmbeddingCollection (which in turn utilizes this).
  
  Example
  -------
  >>> See usage in FusedEmbeddingBagCollection and FusedEmbeddingCollection
code: def __init__(
      self,
      embedding_tables: List[BaseEmbeddingConfig],
      data_type: DataType,
      pooling: PoolingType,
      optimizer_type: EmbOptimType,
      optimizer_kwargs: Dict[str, Any],
      device: torch.device,
      embedding_location: EmbeddingLocation,
  ) -> None:
      super().__init__()
  
      self._rows: List[int] = []
      self._weight_init_mins: List[float] = []
      self._weight_init_maxs: List[float] = []
      self._num_embeddings: List[int] = []
      self._cols: List[int] = []
      self._feature_table_map: List[int] = []
      self._emb_names: List[str] = []
      self._embedding_tables = embedding_tables
  
      for idx, table in enumerate(embedding_tables):
          self._rows.append(table.num_embeddings)
          self._weight_init_mins.append(table.get_weight_init_min())
          self._weight_init_maxs.append(table.get_weight_init_max())
          self._num_embeddings.append(table.num_embeddings)
          self._cols.append(table.embedding_dim)
          self._feature_table_map.extend([idx] * table.num_features())
  
      compute_device = ComputeDevice.CPU
      if device.type == "cuda":
          compute_device = ComputeDevice.CUDA
  
      self._emb_module: SplitTableBatchedEmbeddingBagsCodegen = (
          SplitTableBatchedEmbeddingBagsCodegen(
              list(
                  zip(
                      self._num_embeddings,
                      self._cols,
                      [embedding_location] * len(embedding_tables),
                      [compute_device] * len(embedding_tables),
                  )
              ),
              feature_table_map=self._feature_table_map,
              pooling_mode=pooling_type_to_pooling_mode(pooling),
              device=device,
              optimizer=optimizer_type,
              **optimizer_kwargs,
          )
      )
      self._optim: EmbeddingFusedOptimizer = EmbeddingFusedOptimizer(
          embedding_tables,
          self._emb_module,
      )
  
      self._init_parameters()
  
imports: import copy
  import itertools
  from collections import defaultdict
  from typing import Any, cast, Dict, Iterator, List, Optional, Set, Tuple, Type
  import torch
  import torch.nn
  import torchrec.optim
  from fbgemm_gpu.split_embedding_configs import EmbOptimType
  from fbgemm_gpu.split_table_batched_embeddings_ops_training import ComputeDevice, EmbeddingLocation, SplitTableBatchedEmbeddingBagsCodegen
  from torchrec.modules.embedding_configs import BaseEmbeddingConfig, DataType, EmbeddingBagConfig, EmbeddingConfig, pooling_type_to_pooling_mode, PoolingType
  from torchrec.modules.embedding_modules import EmbeddingBagCollection, EmbeddingBagCollectionInterface, EmbeddingCollection, EmbeddingCollectionInterface, get_embedding_names_by_table
  from torchrec.optim.fused import FusedOptimizer, FusedOptimizerModule
  from torchrec.optim.keyed import CombinedOptimizer, KeyedOptimizer
  from torchrec.sparse.jagged_tensor import JaggedTensor, KeyedJaggedTensor, KeyedTensor
label_desc: Use image node_id 1 to create a new _BatchedFusedEmbeddingLookups object from inherited base classes: nn, FusedOptimizerModule with example: obj = _BatchedFusedEmbeddingLookups(embedding_tables, data_type, pooling, optimizer_type, optimizer_kwargs, device, embedding_location)