class_docstr: Inspects a given class and collects information about its instance
  methods.
  
  Args:
      cls (Type): The class to inspect.
docstr: Returns the union of parameters of all inspected functions in
  :obj:`funcs`.
  
  Args:
      funcs (list[str or callable]): The functions.
      exclude (list[str], optional): The parameter names to exclude.
          (default: :obj:`None`)
docstr_tok: ["Returns","the","union","of","parameters","of","all","inspected","functions","in",":","obj",":","`","funcs","`",".","Args",":","funcs","(","list","[","str","or","callable","]",")",":","The","functions",".","exclude","(","list","[","str","]",",","optional",")",":","The","parameter","names","to","exclude",".","(","default",":",":","obj",":","`","None","`",")"]
code: def get_flat_param_dict(
      self,
      funcs: List[Union[Callable, str]],
      exclude: Optional[List[str]] = None,
  ) -> Dict[str, Parameter]:
      r"""Returns the union of parameters of all inspected functions in
      :obj:`funcs`.
  
      Args:
          funcs (list[str or callable]): The functions.
          exclude (list[str], optional): The parameter names to exclude.
              (default: :obj:`None`)
      """
      param_dict: Dict[str, Parameter] = {}
      for func in funcs:
          params = self.get_params(func, exclude)
          for param in params:
              expected = param_dict.get(param.name)
              if expected is not None and param.type != expected.type:
                  raise ValueError(
                      f"Found inconsistent types for argument "
                      f"'{param.name}'. Expected type "
                      f"'{expected.type}' but found type "
                      f"'{param.type}'."
                  )
  
              if (
                  expected is not None
                  and param.default != expected.default
              ):
                  if (
                      param.default is not inspect._empty
                      and expected.default is not inspect._empty
                  ):
                      raise ValueError(
                          f"Found inconsistent defaults for "
                          f"argument '{param.name}'. Expected "
                          f"'{expected.default}'  but found "
                          f"'{param.default}'."
                      )
  
                  default = expected.default
                  if default is inspect._empty:
                      default = param.default
  
                  param_dict[param.name] = Parameter(
                      name=param.name,
                      type=param.type,
                      type_repr=param.type_repr,
                      default=default,
                  )
  
              if expected is None:
                  param_dict[param.name] = param
  
      return param_dict
  
imports: import inspect
  import re
  import sys
  import typing
  from typing import Any, Callable, Dict, List, NamedTuple, Optional, Type, Union
  from torch import Tensor
label_desc: Use image node_id 12 for calling the Inspector obj's underlying member method code with example usage: obj.get_flat_param_dict(funcs, exclude) and returns: param_dict