code: def _get_human_readable_count(
      number: int, labels: Optional[List[str]] = None
  ) -> str:
      """Abbreviates an integer number with K, M, B, T for thousands, millions, billions and trillions, respectively.
      Examples:
          >>> _get_human_readable_count(123)
          '123  '
          >>> _get_human_readable_count(1234)  # (one thousand)
          '1.2 K'
          >>> _get_human_readable_count(int(2e6))   # (two million)
          '2.0 M'
          >>> _get_human_readable_count(int(3e9))   # (three billion)
          '3.0 B'
          >>> _get_human_readable_count(int(3e9), labels=[" ", "K", "M", "G", "T"])  # (Using units for FLOPs, 3 G)
          '3.0 G'
          >>> _get_human_readable_count(int(4e14))  # (four hundred trillion)
          '400 T'
          >>> _get_human_readable_count(int(5e15))  # (more than trillion)
          '5,000 T'
      Args:
          number: a positive integer number
          labels: a list of units that we want to use per 10^3 digits. Defaults to [" ", "K", "M", "B", "T"]
      Return:
          A string formatted according to the pattern described above.
      Raises:
          ValueError:
              If `number` is less than 0
          TypeError:
              If `number` is not an int
      """
      # logic does not work for floats (e.g. number=0.5)
      if not isinstance(number, int):
          raise TypeError(
              f"Input type must be int, but received {type(number)}"
          )
      if number < 0:
          raise ValueError(
              f"Input value must be greater than 0, received {number}"
          )
      labels = labels or _PARAMETER_NUM_UNITS
      if len(labels) <= 0:
          raise ValueError(
              f"Input labels must be a list with at least one string, received {labels}"
          )
  
      num_digits = int(
          math.floor(math.log10(number)) + 1 if number > 0 else 1
      )
      num_groups = int(math.ceil(num_digits / 3))
      num_groups = min(
          num_groups, len(labels)
      )  # don't abbreviate beyond trillions
      shift = -3 * (num_groups - 1)
      number = number * (10**shift)
      index = num_groups - 1
      if index < 1 or number >= 100:
          return f"{int(number):,d} {labels[index]}"
  
      return f"{number:,.1f} {labels[index]}"
  
imports: import copy
  import math
  import warnings
  from collections import defaultdict, deque
  from dataclasses import dataclass, field
  from enum import Enum
  from time import perf_counter
  from typing import Any, Callable, DefaultDict, Deque, Dict, List, MutableMapping, Optional, Tuple, Union
  import torch
  from torch.nn.parameter import UninitializedParameter
  from torch.utils._pytree import PyTree, tree_flatten
  from torch.utils.hooks import RemovableHandle
  from torchtnt.utils.version import is_torch_version_geq_1_13
  from typing_extensions import Literal
label_desc: Use image node_id 10 for calling a global function with example usage: _get_human_readable_count(number, labels) and returns: number, str, labels, int, str, labels