code: def force_fp32(apply_to=None, out_fp16=False):
      """Decorator to convert input arguments to fp32 in force.
  
      This decorator is useful when you write custom modules and want to support
      mixed precision training. If there are some inputs that must be processed
      in fp32 mode, then this decorator can handle it. If inputs arguments are
      fp16 tensors, they will be converted to fp32 automatically. Arguments other
      than fp16 tensors are ignored. If you are using PyTorch >= 1.6,
      torch.cuda.amp is used as the backend, otherwise, original mmcv
      implementation will be adopted.
  
      Args:
          apply_to (Iterable, optional): The argument names to be converted.
              `None` indicates all arguments.
          out_fp16 (bool): Whether to convert the output back to fp16.
  
      Example:
  
          >>> import torch.nn as nn
          >>> class MyModule1(nn.Module):
          >>>
          >>>     # Convert x and y to fp32
          >>>     @force_fp32()
          >>>     def loss(self, x, y):
          >>>         pass
  
          >>> import torch.nn as nn
          >>> class MyModule2(nn.Module):
          >>>
          >>>     # convert pred to fp32
          >>>     @force_fp32(apply_to=('pred', ))
          >>>     def post_process(self, pred, others):
          >>>         pass
      """
  
      def force_fp32_wrapper(old_func):
          @functools.wraps(old_func)
          def new_func(*args, **kwargs):
              # check if the module has set the attribute `fp16_enabled`, if not,
              # just fallback to the original method.
              if not isinstance(args[0], torch.nn.Module):
                  raise TypeError(
                      "@force_fp32 can only be used to decorate the "
                      "method of nn.Module"
                  )
              if not (
                  hasattr(args[0], "fp16_enabled")
                  and args[0].fp16_enabled
              ):
                  return old_func(*args, **kwargs)
              # get the arg spec of the decorated method
              args_info = getfullargspec(old_func)
              # get the argument names to be casted
              args_to_cast = (
                  args_info.args if apply_to is None else apply_to
              )
              # convert the args that need to be processed
              new_args = []
              if args:
                  arg_names = args_info.args[: len(args)]
                  for i, arg_name in enumerate(arg_names):
                      if arg_name in args_to_cast:
                          new_args.append(
                              cast_tensor_type(
                                  args[i], torch.half, torch.float
                              )
                          )
                      else:
                          new_args.append(args[i])
              # convert the kwargs that need to be processed
              new_kwargs = dict()
              if kwargs:
                  for arg_name, arg_value in kwargs.items():
                      if arg_name in args_to_cast:
                          new_kwargs[arg_name] = cast_tensor_type(
                              arg_value, torch.half, torch.float
                          )
                      else:
                          new_kwargs[arg_name] = arg_value
              # apply converted arguments to the decorated method
              if TORCH_VERSION != "parrots" and digit_version(
                  TORCH_VERSION
              ) >= digit_version("1.6.0"):
                  with autocast(enabled=False):
                      output = old_func(*new_args, **new_kwargs)
              else:
                  output = old_func(*new_args, **new_kwargs)
              # cast the results back to fp32 if necessary
              if out_fp16:
                  output = cast_tensor_type(
                      output, torch.float, torch.half
                  )
              return output
  
          return new_func
  
      return force_fp32_wrapper
  
imports: import functools
  import warnings
  from collections import abc
  from inspect import getfullargspec
  import numpy
  import torch
  import torch.nn
  from annotator.uniformer.mmcv.utils import TORCH_VERSION, digit_version
  from .dist_utils import allreduce_grads
label_desc: Use image node_id 3 for calling a global function with example usage: force_fp32(apply_to, out_fp16) and returns: force_fp32_wrapper, new_func, output, old_func