code: def _scale_stage_depth(
      stack_args, repeats, depth_multiplier=1.0, depth_trunc="ceil"
  ):
      """Per-stage depth scaling
      Scales the block repeats in each stage. This depth scaling impl maintains
      compatibility with the EfficientNet scaling method, while allowing sensible
      scaling for other models that may have multiple block arg definitions in each stage.
      """
  
      # We scale the total repeat count for each stage, there may be multiple
      # block arg defs per stage so we need to sum.
      num_repeat = sum(repeats)
      if depth_trunc == "round":
          # Truncating to int by rounding allows stages with few repeats to remain
          # proportionally smaller for longer. This is a good choice when stage definitions
          # include single repeat stages that we'd prefer to keep that way as long as possible
          num_repeat_scaled = max(
              1, round(num_repeat * depth_multiplier)
          )
      else:
          # The default for EfficientNet truncates repeats to int via 'ceil'.
          # Any multiplier > 1.0 will result in an increased depth for every stage.
          num_repeat_scaled = int(
              math.ceil(num_repeat * depth_multiplier)
          )
  
      # Proportionally distribute repeat count scaling to each block definition in the stage.
      # Allocation is done in reverse as it results in the first block being less likely to be scaled.
      # The first block makes less sense to repeat in most of the arch definitions.
      repeats_scaled = []
      for r in repeats[::-1]:
          rs = max(1, round((r / num_repeat * num_repeat_scaled)))
          repeats_scaled.append(rs)
          num_repeat -= r
          num_repeat_scaled -= rs
      repeats_scaled = repeats_scaled[::-1]
  
      # Apply the calculated scaling to each block arg in the stage
      sa_scaled = []
      for ba, rep in zip(stack_args, repeats_scaled):
          sa_scaled.extend([deepcopy(ba) for _ in range(rep)])
      return sa_scaled
  
imports: import re
  from copy import deepcopy
  from .conv2d_layers import *
  from geffnet.activations import *
label_desc: Use image node_id 10 for calling a global function with example usage: _scale_stage_depth(stack_args, repeats, depth_multiplier, depth_trunc) and returns: sa_scaled