code: def all_reduce_dict(py_dict, op="sum", group=None, to_float=True):
      """Apply all reduce function for python dict object.
  
      The code is modified from https://github.com/Megvii-
      BaseDetection/YOLOX/blob/main/yolox/utils/allreduce_norm.py.
  
      NOTE: make sure that py_dict in different ranks has the same keys and
      the values should be in the same shape. Currently only supports
      nccl backend.
  
      Args:
          py_dict (dict): Dict to be applied all reduce op.
          op (str): Operator, could be 'sum' or 'mean'. Default: 'sum'
          group (:obj:`torch.distributed.group`, optional): Distributed group,
              Default: None.
          to_float (bool): Whether to convert all values of dict to float.
              Default: True.
  
      Returns:
          OrderedDict: reduced python dict object.
      """
      warnings.warn(
          "group` is deprecated. Currently only supports NCCL backend."
      )
      _, world_size = get_dist_info()
      if world_size == 1:
          return py_dict
  
      # all reduce logic across different devices.
      py_key = list(py_dict.keys())
      if not isinstance(py_dict, OrderedDict):
          py_key_tensor = obj2tensor(py_key)
          dist.broadcast(py_key_tensor, src=0)
          py_key = tensor2obj(py_key_tensor)
  
      tensor_shapes = [py_dict[k].shape for k in py_key]
      tensor_numels = [py_dict[k].numel() for k in py_key]
  
      if to_float:
          warnings.warn(
              'Note: the "to_float" is True, you need to '
              "ensure that the behavior is reasonable."
          )
          flatten_tensor = torch.cat(
              [py_dict[k].flatten().float() for k in py_key]
          )
      else:
          flatten_tensor = torch.cat(
              [py_dict[k].flatten() for k in py_key]
          )
  
      dist.all_reduce(flatten_tensor, op=dist.ReduceOp.SUM)
      if op == "mean":
          flatten_tensor /= world_size
  
      split_tensors = [
          x.reshape(shape)
          for x, shape in zip(
              torch.split(flatten_tensor, tensor_numels), tensor_shapes
          )
      ]
      out_dict = {k: v for k, v in zip(py_key, split_tensors)}
      if isinstance(py_dict, OrderedDict):
          out_dict = OrderedDict(out_dict)
      return out_dict
  
file_path: mmdetection/mmdet/utils/dist_utils.py
imports: import functools
  import pickle
  import warnings
  from collections import OrderedDict
  import numpy
  import torch
  import torch.distributed
  from mmengine.dist import get_dist_info
  from torch._utils import _flatten_dense_tensors, _take_tensors, _unflatten_dense_tensors
label_desc: Use image node_id 7 for calling a global function with example usage: all_reduce_dict(py_dict, op, group, to_float) and returns: out_dict, py_dict