class_docstr: Base class for any neural network
class_docstr_tok: ["Base","class","for","any","neural","network"]
docstr: Prints model, parameters, and FLOPs on start rank.
docstr_tok: ["Prints","model",",","parameters",",","and","FLOPs","on","start","rank","."]
code: def info(self) -> None:
      """Prints model, parameters, and FLOPs on start rank."""
  
      train_mode = False
      if self.training:
          # do profiling in eval mode
          train_mode = True
          self.eval()
  
      logger.log(logger.color_text("Model"))
      # print the model skeleton
      print(self)
  
      logger.double_dash_line(dashes=65)
      print("{:>35} Summary".format(self.__class__.__name__))
      logger.double_dash_line(dashes=65)
  
      # compute the network parameters
      overall_params = sum([p.numel() for p in self.parameters()])
      print(
          "{:<20} = {:>8.3f} M".format(
              "Overall parameters", overall_params / 1e6
          )
      )
  
      try:
          # Compute FLOPs using FVCore
          try:
              input_fvcore = self.dummy_input_and_label(batch_size=1)[
                  "samples"
              ]
          except NotImplementedError:
              logger.warning(
                  "Profiling not available, dummy_input_and_label not implemented for this model."
              )
              return
  
          # compute flops using FVCore
          from fvcore.nn import FlopCountAnalysis, flop_count_table
  
          flop_analyzer = FlopCountAnalysis(self, input_fvcore)
          logger.log(f"FVCore Analysis:")
          # print input sizes
          input_sizes = get_tensor_sizes(input_fvcore)
          logger.log("Input sizes: {}".format(input_sizes))
          print(flop_count_table(flop_analyzer))
  
          logger.warning(
              "\n** Please be cautious when using the results in papers. "
              "Certain operations may or may not be accounted in FLOP computation in FVCore. "
              "Therefore, you want to manually ensure that FLOP computation is correct."
          )
  
          uncalled_modules = flop_analyzer.uncalled_modules()
          if len(uncalled_modules) > 0:
              logger.warning(f"Uncalled Modules:\n{uncalled_modules}")
          else:
              logger.log(f"No uncalled modules detected by fvcore.")
  
          unsupported_ops = flop_analyzer.unsupported_ops()
          if len(unsupported_ops) > 0:
              logger.warning(f"Unsupported Ops:\n{unsupported_ops}")
          else:
              logger.log(f"No unsupported ops detected by fvcore.")
      except:
          logger.ignore_exception_with_warning(
              "Unable to compute FLOPs using FVCore. Please check"
          )
      logger.double_dash_line(dashes=65)
  
      if train_mode:
          # switching back to train mode.
          self.train()
  
imports: from __future__ import annotations
  import argparse
  import traceback
  from typing import Any, Dict, List, Mapping, Optional, Tuple
  import torch
  from torch import nn
  from cvnets.layers import norm_layers_tuple
  from cvnets.misc.common import get_tensor_sizes, parameter_list
  from cvnets.misc.init_utils import initialize_weights
  from options.parse_args import JsonValidator
  from utils import logger
  from utils.common_utils import check_frozen_norm_layer
  from utils.ddp_utils import is_master
label_desc: Use image node_id 11 for calling the BaseAnyNNModel obj's underlying member method code with example usage: obj.info() without return types