code: def _create_homogeneous_sparse_graphs_from_csc(
      tensors_dict: Dict[int, Dict[int, Dict[str, torch.Tensor]]],
      renumber_map_list: List[torch.Tensor],
      mfg_sizes: List[int, int],
  ) -> List[List[torch.Tensor, torch.Tensor, List[SparseGraph]]]:
      """Create mini-batches of MFGs. The input arguments are the outputs of
      the function `_process_sampled_df_csc`.
  
      Returns
      -------
      output: list
          A list of mini-batches. Each mini-batch is a list that consists of
          `input_nodes` tensor, `output_nodes` tensor and a list of MFGs.
      """
      n_batches, n_hops = len(mfg_sizes), len(mfg_sizes[0]) - 1
      output = []
      for b_id in range(n_batches):
          output_batch = []
          output_batch.append(renumber_map_list[b_id])
          output_batch.append(
              renumber_map_list[b_id][: mfg_sizes[b_id][-1]]
          )
          mfgs = [
              SparseGraph(
                  size=(
                      mfg_sizes[b_id][h_id],
                      mfg_sizes[b_id][h_id + 1],
                  ),
                  src_ids=tensors_dict[b_id][h_id]["minors"],
                  cdst_ids=tensors_dict[b_id][h_id]["major_offsets"],
                  formats=["csc"],
                  reduce_memory=True,
              )
              for h_id in range(n_hops)
          ]
  
          output_batch.append(mfgs)
  
          output.append(output_batch)
  
      return output
  
imports: from __future__ import annotations
  from typing import List, Tuple, Dict, Optional
  from collections import defaultdict
  import cudf
  from cugraph.utilities.utils import import_optional
  from cugraph_dgl.nn import SparseGraph
label_desc: Use image node_id 16 for calling a global function with example usage: _create_homogeneous_sparse_graphs_from_csc(tensors_dict, renumber_map_list, mfg_sizes) and returns: output