code: def _resnet_fpn_extractor(
      backbone: resnet.ResNet,
      spatial_dims: int,
      trainable_layers: int = 5,
      returned_layers: list[int] | None = None,
      extra_blocks: ExtraFPNBlock | None = None,
  ) -> BackboneWithFPN:
      """
      Same code as https://github.com/pytorch/vision/blob/release/0.12/torchvision/models/detection/backbone_utils.py
      Except that ``in_channels_stage2 = backbone.in_planes // 8`` instead of ``in_channels_stage2 = backbone.inplanes // 8``,
      and it requires spatial_dims: 2D or 3D images.
      """
  
      # select layers that wont be frozen
      if trainable_layers < 0 or trainable_layers > 5:
          raise ValueError(
              f"Trainable layers should be in the range [0,5], got {trainable_layers}"
          )
      layers_to_train = [
          "layer4",
          "layer3",
          "layer2",
          "layer1",
          "conv1",
      ][:trainable_layers]
      if trainable_layers == 5:
          layers_to_train.append("bn1")
      for name, parameter in backbone.named_parameters():
          if all(
              not name.startswith(layer) for layer in layers_to_train
          ):
              parameter.requires_grad_(False)
  
      if extra_blocks is None:
          extra_blocks = LastLevelMaxPool(spatial_dims)
  
      if returned_layers is None:
          returned_layers = [1, 2, 3, 4]
      if min(returned_layers) <= 0 or max(returned_layers) >= 5:
          raise ValueError(
              f"Each returned layer should be in the range [1,4]. Got {returned_layers}"
          )
      return_layers = {
          f"layer{k}": str(v) for v, k in enumerate(returned_layers)
      }
  
      in_channels_stage2 = backbone.in_planes // 8
      in_channels_list = [
          in_channels_stage2 * 2 ** (i - 1) for i in returned_layers
      ]
      out_channels = 256
      return BackboneWithFPN(
          backbone,
          return_layers,
          in_channels_list,
          out_channels,
          extra_blocks=extra_blocks,
          spatial_dims=spatial_dims,
      )
  
file_path: MONAI/monai/networks/blocks/backbone_fpn_utils.py
imports: from __future__ import annotations
  from torch import Tensor, nn
  from monai.networks.nets import resnet
  from monai.utils import optional_import
  from .feature_pyramid_network import ExtraFPNBlock, FeaturePyramidNetwork, LastLevelMaxPool
label_desc: Use image node_id 1 for calling a global function with example usage: _resnet_fpn_extractor(backbone, spatial_dims, trainable_layers, returned_layers, extra_blocks) and returns: BackboneWithFPN