class_docstr: Multi-scale RoIAlign pooling, which is useful for detection with or without FPN.
  
  It infers the scale of the pooling via the heuristics specified in eq. 1
  of the `Feature Pyramid Network paper <https://arxiv.org/abs/1612.03144>`_.
  They keyword-only parameters ``canonical_scale`` and ``canonical_level``
  correspond respectively to ``224`` and ``k0=4`` in eq. 1, and
  have the following meaning: ``canonical_level`` is the target level of the pyramid from
  which to pool a region of interest with ``w x h = canonical_scale x canonical_scale``.
  
  Args:
      featmap_names (List[str]): the names of the feature maps that will be used
          for the pooling.
      output_size (List[Tuple[int, int]] or List[int]): output size for the pooled region
      sampling_ratio (int): sampling ratio for ROIAlign
      canonical_scale (int, optional): canonical_scale for LevelMapper
      canonical_level (int, optional): canonical_level for LevelMapper
  
  Examples::
  
      >>> m = torchvision.ops.MultiScaleRoIAlign(['feat1', 'feat3'], 3, 2)
      >>> i = OrderedDict()
      >>> i['feat1'] = torch.rand(1, 5, 64, 64)
      >>> i['feat2'] = torch.rand(1, 5, 32, 32)  # this feature won't be used in the pooling
      >>> i['feat3'] = torch.rand(1, 5, 16, 16)
      >>> # create some random bounding boxes
      >>> boxes = torch.rand(6, 4) * 256; boxes[:, 2:] += boxes[:, :2]
      >>> # original image size, before computing the feature maps
      >>> image_sizes = [(512, 512)]
      >>> output = m(i, [boxes], image_sizes)
      >>> print(output.shape)
      >>> torch.Size([6, 5, 3, 3])
code: def __init__(
      self,
      featmap_names: List[str],
      output_size: Union[int, Tuple[int], List[int]],
      sampling_ratio: int,
      *,
      canonical_scale: int = 224,
      canonical_level: int = 4,
  ):
      super().__init__()
      _log_api_usage_once(self)
      if isinstance(output_size, int):
          output_size = (output_size, output_size)
      self.featmap_names = featmap_names
      self.sampling_ratio = sampling_ratio
      self.output_size = tuple(output_size)
      self.scales = None
      self.map_levels = None
      self.canonical_scale = canonical_scale
      self.canonical_level = canonical_level
  
imports: from typing import Dict, List, Optional, Tuple, Union
  import torch
  import torch.fx
  import torchvision
  from torch import nn, Tensor
  from torchvision.ops.boxes import box_area
  from ..utils import _log_api_usage_once
  from .roi_align import roi_align
label_desc: Use image node_id 1 to create a new MultiScaleRoIAlign object from inherited base classes: nn with example: obj = MultiScaleRoIAlign(featmap_names, output_size, sampling_ratio)