class_docstr: Constructs a Conditional Detr image processor.
  
  Args:
      format (`str`, *optional*, defaults to `"coco_detection"`):
          Data format of the annotations. One of "coco_detection" or "coco_panoptic".
      do_resize (`bool`, *optional*, defaults to `True`):
          Controls whether to resize the image's (height, width) dimensions to the specified `size`. Can be
          overridden by the `do_resize` parameter in the `preprocess` method.
      size (`Dict[str, int]` *optional*, defaults to `{"shortest_edge": 800, "longest_edge": 1333}`):
          Size of the image's (height, width) dimensions after resizing. Can be overridden by the `size` parameter in
          the `preprocess` method.
      resample (`PILImageResampling`, *optional*, defaults to `PILImageResampling.BILINEAR`):
          Resampling filter to use if resizing the image.
      do_rescale (`bool`, *optional*, defaults to `True`):
          Controls whether to rescale the image by the specified scale `rescale_factor`. Can be overridden by the
          `do_rescale` parameter in the `preprocess` method.
      rescale_factor (`int` or `float`, *optional*, defaults to `1/255`):
          Scale factor to use if rescaling the image. Can be overridden by the `rescale_factor` parameter in the
          `preprocess` method.
      do_normalize:
          Controls whether to normalize the image. Can be overridden by the `do_normalize` parameter in the
          `preprocess` method.
      image_mean (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_MEAN`):
          Mean values to use when normalizing the image. Can be a single value or a list of values, one for each
          channel. Can be overridden by the `image_mean` parameter in the `preprocess` method.
      image_std (`float` or `List[float]`, *optional*, defaults to `IMAGENET_DEFAULT_STD`):
          Standard deviation values to use when normalizing the image. Can be a single value or a list of values, one
          for each channel. Can be overridden by the `image_std` parameter in the `preprocess` method.
      do_pad (`bool`, *optional*, defaults to `True`):
          Controls whether to pad the image to the largest image in a batch and create a pixel mask. Can be
          overridden by the `do_pad` parameter in the `preprocess` method.
docstr: Converts the output of [`ConditionalDetrForSegmentation`] into semantic segmentation maps. Only supports PyTorch.
  
  Args:
      outputs ([`ConditionalDetrForSegmentation`]):
          Raw outputs of the model.
      target_sizes (`List[Tuple[int, int]]`, *optional*):
          A list of tuples (`Tuple[int, int]`) containing the target size (height, width) of each image in the
          batch. If unset, predictions will not be resized.
  Returns:
      `List[torch.Tensor]`:
          A list of length `batch_size`, where each item is a semantic segmentation map of shape (height, width)
          corresponding to the target_sizes entry (if `target_sizes` is specified). Each entry of each
          `torch.Tensor` correspond to a semantic class id.
docstr_tok: ["Converts","the","output","of","[","`","ConditionalDetrForSegmentation","`","]","into","semantic","segmentation","maps",".","Only","supports","PyTorch",".","Args",":","outputs","(","[","`","ConditionalDetrForSegmentation","`","]",")",":","Raw","outputs","of","the","model",".","target_sizes","(","`","List","[","Tuple","[","int",",","int","]","]","`",",","*","optional","*",")",":","A","list","of","tuples","(","`","Tuple","[","int",",","int","]","`",")","containing","the","target","size","(","height",",","width",")","of","each","image","in","the","batch",".","If","unset",",","predictions","will","not","be","resized",".","Returns",":","`","List","[","torch.Tensor","]","`",":","A","list","of","length","`","batch_size","`",",","where","each","item","is","a","semantic","segmentation","map","of","shape","(","height",",","width",")","corresponding","to","the","target_sizes","entry","(","if","`","target_sizes","`","is","specified",")",".","Each","entry","of","each","`","torch.Tensor","`","correspond","to","a","semantic","class","id","."]
code: def post_process_semantic_segmentation(
      self, outputs, target_sizes: List[Tuple[int, int]] = None
  ):
      """
      Converts the output of [`ConditionalDetrForSegmentation`] into semantic segmentation maps. Only supports PyTorch.
  
      Args:
          outputs ([`ConditionalDetrForSegmentation`]):
              Raw outputs of the model.
          target_sizes (`List[Tuple[int, int]]`, *optional*):
              A list of tuples (`Tuple[int, int]`) containing the target size (height, width) of each image in the
              batch. If unset, predictions will not be resized.
      Returns:
          `List[torch.Tensor]`:
              A list of length `batch_size`, where each item is a semantic segmentation map of shape (height, width)
              corresponding to the target_sizes entry (if `target_sizes` is specified). Each entry of each
              `torch.Tensor` correspond to a semantic class id.
      """
      class_queries_logits = (
          outputs.logits
      )  # [batch_size, num_queries, num_classes+1]
      masks_queries_logits = (
          outputs.pred_masks
      )  # [batch_size, num_queries, height, width]
  
      # Remove the null class `[..., :-1]`
      masks_classes = class_queries_logits.softmax(dim=-1)[..., :-1]
      masks_probs = (
          masks_queries_logits.sigmoid()
      )  # [batch_size, num_queries, height, width]
  
      # Semantic segmentation logits of shape (batch_size, num_classes, height, width)
      segmentation = torch.einsum(
          "bqc, bqhw -> bchw", masks_classes, masks_probs
      )
      batch_size = class_queries_logits.shape[0]
  
      # Resize logits and compute semantic segmentation maps
      if target_sizes is not None:
          if batch_size != len(target_sizes):
              raise ValueError(
                  "Make sure that you pass in as many target sizes as the batch dimension of the logits"
              )
  
          semantic_segmentation = []
          for idx in range(batch_size):
              resized_logits = nn.functional.interpolate(
                  segmentation[idx].unsqueeze(dim=0),
                  size=target_sizes[idx],
                  mode="bilinear",
                  align_corners=False,
              )
              semantic_map = resized_logits[0].argmax(dim=0)
              semantic_segmentation.append(semantic_map)
      else:
          semantic_segmentation = segmentation.argmax(dim=1)
          semantic_segmentation = [
              semantic_segmentation[i]
              for i in range(semantic_segmentation.shape[0])
          ]
  
      return semantic_segmentation
  
imports: import io
  import pathlib
  from collections import defaultdict
  from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Tuple, Union
  import numpy
  from ...feature_extraction_utils import BatchFeature
  from ...image_processing_utils import BaseImageProcessor, get_size_dict
  from ...image_transforms import PaddingMode, center_to_corners_format, corners_to_center_format, id_to_rgb, pad, rescale, resize, rgb_to_id, to_channel_dimension_format
  from ...image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, AnnotationFormat, AnnotationType, ChannelDimension, ImageInput, PILImageResampling, get_image_size, infer_channel_dimension_format, is_scaled_image, make_list_of_images, to_numpy_array, valid_images, validate_annotations
  from ...utils import TensorType, is_flax_available, is_jax_tensor, is_scipy_available, is_tf_available, is_tf_tensor, is_torch_available, is_torch_tensor, is_vision_available, logging
label_desc: Use image node_id 17 for calling the ConditionalDetrImageProcessor obj's underlying member method code with example usage: obj.post_process_semantic_segmentation(outputs, target_sizes) and returns: semantic_segmentation