


import argparse
import hashlib
import os
import urllib
import warnings

import torch
from torch import nn
from tqdm import tqdm

from transformers import WhisperConfig, WhisperForConditionalGeneration


A      :    Tuple		=					{
    "tiny.en": "https://openaipublic.azureedge.net/main/whisper/models/d3dd57d32accea0b295c96e26691aa14d8822fac7d9d27d5dc00b4ca2826dd03/tiny.en.pt",
    "tiny": "https://openaipublic.azureedge.net/main/whisper/models/65147644a518d12f04e32d6f3b26facc3f8dd46e5390956a9424a650c0ce22b9/tiny.pt",
    "base.en": "https://openaipublic.azureedge.net/main/whisper/models/25a8566e1d0c1e2231d1c762132cd20e0f96a85d16145c3a00adf5d1ac670ead/base.en.pt",
    "base": "https://openaipublic.azureedge.net/main/whisper/models/ed3a0b6b1c0edf879ad9b11b1af5a0e6ab5db9205f891f668f8b0e6c6326e34e/base.pt",
    "small.en": "https://openaipublic.azureedge.net/main/whisper/models/f953ad0fd29cacd07d5a9eda5624af0f6bcf2258be67c92b79389873d91e0872/small.en.pt",
    "small": "https://openaipublic.azureedge.net/main/whisper/models/9ecf779972d90ba49c06d968637d720dd632c55bbf19d441fb42bf17a411e794/small.pt",
    "medium.en": "https://openaipublic.azureedge.net/main/whisper/models/d7440d1dc186f76616474e0ff0b3b6b879abc9d1a4926b7adfa41db2d497ab4f/medium.en.pt",
    "medium": "https://openaipublic.azureedge.net/main/whisper/models/345ae4da62f9b3d59415adc60127b97c714f32e89e936602e85993674d08dcb1/medium.pt",
    "large": "https://openaipublic.azureedge.net/main/whisper/models/e4b87e7e0bf463eb8e6956e646f1e277e901512310def2c24bf0e11bd3c28e9a/large.pt",
    "large-v2": "https://openaipublic.azureedge.net/main/whisper/models/81f7c96c852ee8fc832187b0132e569d6c3065a3252ed18e56effd0b6a73e524/large-v2.pt",
}

def       lowercase_		(		_A			:    Tuple						):

      """simple docstring"""




      lowerCamelCase__		:				Optional[int]    =  ["layers", "blocks"]
      for k in ignore_keys:
            state_dict.pop(_A    ,					_A						)


A      :    Optional[int]		=					{
    "blocks": "layers",
    "mlp.0": "fc1",
    "mlp.2": "fc2",
    "mlp_ln": "final_layer_norm",
    ".attn.query": ".self_attn.q_proj",
    ".attn.key": ".self_attn.k_proj",
    ".attn.value": ".self_attn.v_proj",
    ".attn_ln": ".self_attn_layer_norm",
    ".attn.out": ".self_attn.out_proj",
    ".cross_attn.query": ".encoder_attn.q_proj",
    ".cross_attn.key": ".encoder_attn.k_proj",
    ".cross_attn.value": ".encoder_attn.v_proj",
    ".cross_attn_ln": ".encoder_attn_layer_norm",
    ".cross_attn.out": ".encoder_attn.out_proj",
    "decoder.ln.": "decoder.layer_norm.",
    "encoder.ln.": "encoder.layer_norm.",
    "token_embedding": "embed_tokens",
    "encoder.positional_embedding": "encoder.embed_positions.weight",
    "decoder.positional_embedding": "decoder.embed_positions.weight",
    "ln_post": "layer_norm",
}

def       lowercase_		(		_A			:    Union[str, Any]						):

      """simple docstring"""




      lowerCamelCase__		:				Tuple    =  list(s_dict.keys()						)
      for key in keys:
            lowerCamelCase__		:				Optional[int]    =  key
            for k, v in WHISPER_MAPPING.items():
                  if k in key:
                        lowerCamelCase__		:				Optional[Any]    =  new_key.replace(_A    ,					_A						)

            print(F"{key} -> {new_key}"						)

            lowerCamelCase__		:				Tuple    =  s_dict.pop(_A						)
      return s_dict

def       lowercase_		(		_A			:    Dict						):

      """simple docstring"""




      lowerCamelCase__    ,   lowerCamelCase__		:				List[str]    =  emb.weight.shape
      lowerCamelCase__		:				int    =  nn.Linear(_A    ,					_A    ,					bias=_A						)
      lowerCamelCase__		:				int    =  emb.weight.data
      return lin_layer

def       lowercase_		(		_A			:    str    ,					_A			:    str						):

      """simple docstring"""




      os.makedirs(_A    ,					exist_ok=_A						)
      lowerCamelCase__		:				Tuple    =  os.path.basename(_A						)

      lowerCamelCase__		:				str    =  url.split("/"						)[-2]
      lowerCamelCase__		:				List[Any]    =  os.path.join(_A    ,					_A						)

      if os.path.exists(_A						) and not os.path.isfile(_A						):
            raise RuntimeError(F"{download_target} exists and is not a regular file"						)

      if os.path.isfile(_A						):
            lowerCamelCase__		:				List[str]    =  open(_A    ,					"rb"						).read()
            if hashlib.shaaaa(_A						).hexdigest() == expected_shaaaa:
                  return model_bytes
            else:
                  warnings.warn(F"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file"						)

      with urllib.request.urlopen(_A						) as source, open(_A    ,					"wb"						) as output:
            with tqdm(
                total=int(source.info().get("Content-Length"						)						)    ,					ncols=80    ,					unit="iB"    ,					unit_scale=_A    ,					unit_divisor=1024						) as loop:
                  while True:
                        lowerCamelCase__		:				Any    =  source.read(8192						)
                        if not buffer:
                              break

                        output.write(_A						)
                        loop.update(len(_A						)						)

      lowerCamelCase__		:				Any    =  open(_A    ,					"rb"						).read()
      if hashlib.shaaaa(_A						).hexdigest() != expected_shaaaa:
            raise RuntimeError(
                "Model has been downloaded but the SHA256 checksum does not not match. Please retry loading the model."						)

      return model_bytes

def       lowercase_		(		_A			:    Optional[Any]    ,					_A			:    Union[str, Any]						):

      """simple docstring"""




      if ".pt" not in checkpoint_path:
            lowerCamelCase__		:				Optional[int]    =  _download(_MODELS[checkpoint_path]						)
      else:
            lowerCamelCase__		:				int    =  torch.load(_A    ,					map_location="cpu"						)
      lowerCamelCase__		:				Optional[Any]    =  original_checkpoint["dims"]
      lowerCamelCase__		:				Any    =  original_checkpoint["model_state_dict"]
      lowerCamelCase__		:				List[Any]    =  state_dict["decoder.token_embedding.weight"]
      remove_ignore_keys_(_A						)
      rename_keys(_A						)
      lowerCamelCase__		:				Optional[int]    =  True
      lowerCamelCase__		:				str    =  state_dict["decoder.layers.0.fc1.weight"].shape[0]

      lowerCamelCase__		:				Union[str, Any]    =  WhisperConfig(
          vocab_size=dimensions["n_vocab"]    ,					encoder_ffn_dim=_A    ,					decoder_ffn_dim=_A    ,					num_mel_bins=dimensions["n_mels"]    ,					d_model=dimensions["n_audio_state"]    ,					max_target_positions=dimensions["n_text_ctx"]    ,					encoder_layers=dimensions["n_audio_layer"]    ,					encoder_attention_heads=dimensions["n_audio_head"]    ,					decoder_layers=dimensions["n_text_layer"]    ,					decoder_attention_heads=dimensions["n_text_state"]    ,					max_source_positions=dimensions["n_audio_ctx"]    ,					)

      lowerCamelCase__		:				List[str]    =  WhisperForConditionalGeneration(_A						)
      lowerCamelCase__    ,   lowerCamelCase__		:				Union[str, Any]    =  model.model.load_state_dict(_A    ,					strict=_A						)
      if len(_A						) > 0 and not set(_A						) <= {
          "encoder.embed_positions.weights",
          "decoder.embed_positions.weights",
      }:
            raise ValueError(
                "Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,"
                F" but all the following weights are missing {missing}"						)

      if tie_embeds:
            lowerCamelCase__		:				str    =  make_linear_from_emb(model.model.decoder.embed_tokens						)
      else:
            lowerCamelCase__		:				Optional[Any]    =  proj_out_weights

      model.save_pretrained(_A						)


if __name__ == "__main__":
    A      :    Dict		=					argparse.ArgumentParser()
    # # Required parameters
    parser.add_argument("--checkpoint_path", type=str, help="Patht to the downloaded checkpoints")
    parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
    A      :    List[str]		=					parser.parse_args()

    convert_openai_whisper_to_tfms(args.checkpoint_path, args.pytorch_dump_folder_path)






import json
import pathlib
import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import DetaImageProcessor







class 			_lowercase (							unittest.TestCase):


       """simple docstring"""




       def __init__(   self							:			Any					,      __lowerCamelCase							:			List[str]					,      __lowerCamelCase							:			List[Any]=7					,      __lowerCamelCase							:			Dict=3					,      __lowerCamelCase							:			Union[str, Any]=30					,      __lowerCamelCase							:			Union[str, Any]=400					,      __lowerCamelCase							:			Dict=True					,      __lowerCamelCase							:			Tuple=None					,      __lowerCamelCase							:			str=True					,      __lowerCamelCase							:			List[str]=[0.5, 0.5, 0.5]					,      __lowerCamelCase							:			str=[0.5, 0.5, 0.5]					,      __lowerCamelCase							:			Any=True					,      __lowerCamelCase							:			Union[str, Any]=1 / 255					,      __lowerCamelCase							:			Optional[Any]=True					,      ):


             '''simple docstring'''



             lowerCamelCase__		:				List[Any]    =  size if size is not None else {"shortest_edge": 18, "longest_edge": 1333}
             lowerCamelCase__		:				Dict    =  parent
             lowerCamelCase__		:				Optional[int]    =  batch_size
             lowerCamelCase__		:				str    =  num_channels
             lowerCamelCase__		:				Optional[Any]    =  min_resolution
             lowerCamelCase__		:				List[Any]    =  max_resolution
             lowerCamelCase__		:				int    =  do_resize
             lowerCamelCase__		:				Union[str, Any]    =  size
             lowerCamelCase__		:				Union[str, Any]    =  do_normalize
             lowerCamelCase__		:				int    =  image_mean
             lowerCamelCase__		:				Optional[int]    =  image_std
             lowerCamelCase__		:				List[Any]    =  do_rescale
             lowerCamelCase__		:				Optional[Any]    =  rescale_factor
             lowerCamelCase__		:				Any    =  do_pad





       def 						lowerCAmelCase     (   self							:			List[str]       ):


             '''simple docstring'''



             return {
                 "do_resize": self.do_resize,
                 "size": self.size,
                 "do_normalize": self.do_normalize,
                 "image_mean": self.image_mean,
                 "image_std": self.image_std,
                 "do_rescale": self.do_rescale,
                 "rescale_factor": self.rescale_factor,
                 "do_pad": self.do_pad,
             }





       def 						lowerCAmelCase     (   self							:			List[Any]					,      __lowerCamelCase							:			int					,      __lowerCamelCase							:			List[str]=False       ):


             '''simple docstring'''



             if not batched:
                   lowerCamelCase__		:				Tuple    =  image_inputs[0]
                   if isinstance(__lowerCamelCase					,      Image.Image       ):
                         lowerCamelCase__    ,   lowerCamelCase__		:				Tuple    =  image.size
                   else:
                         lowerCamelCase__    ,   lowerCamelCase__		:				List[str]    =  image.shape[1], image.shape[2]
                   if w < h:
                         lowerCamelCase__		:				List[Any]    =  int(self.size["shortest_edge"] * h / w       )
                         lowerCamelCase__		:				Optional[Any]    =  self.size["shortest_edge"]
                   elif w > h:
                         lowerCamelCase__		:				List[Any]    =  self.size["shortest_edge"]
                         lowerCamelCase__		:				List[str]    =  int(self.size["shortest_edge"] * w / h       )
                   else:
                         lowerCamelCase__		:				Optional[int]    =  self.size["shortest_edge"]
                         lowerCamelCase__		:				Union[str, Any]    =  self.size["shortest_edge"]

             else:
                   lowerCamelCase__		:				Dict    =  []
                   for image in image_inputs:
                         lowerCamelCase__    ,   lowerCamelCase__		:				Union[str, Any]    =  self.get_expected_values([image]       )
                         expected_values.append((expected_height, expected_width)       )
                   lowerCamelCase__		:				str    =  max(__lowerCamelCase					,      key=lambda __lowerCamelCase       : item[0]       )[0]
                   lowerCamelCase__		:				Optional[Any]    =  max(__lowerCamelCase					,      key=lambda __lowerCamelCase       : item[1]       )[1]

             return expected_height, expected_width







@require_torch
@require_vision
class 			_lowercase (							lowercase__							,  unittest.TestCase):


       """simple docstring"""




       A__											=			DetaImageProcessor if is_vision_available() else None





       def 						lowerCAmelCase     (   self							:			List[str]       ):


             '''simple docstring'''



             lowerCamelCase__		:				str    =  DetaImageProcessingTester(self       )





       @property
       def 						lowerCAmelCase     (   self							:			Union[str, Any]       ):


             '''simple docstring'''



             return self.image_processor_tester.prepare_image_processor_dict()





       def 						lowerCAmelCase     (   self							:			Dict       ):


             '''simple docstring'''



             lowerCamelCase__		:				int    =  self.image_processing_class(**self.image_processor_dict       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "image_mean"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "image_std"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "do_normalize"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "do_resize"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "do_rescale"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "do_pad"       )       )
             self.assertTrue(hasattr(__lowerCamelCase					,      "size"       )       )





       def 						lowerCAmelCase     (   self							:			List[str]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Any    =  self.image_processing_class.from_dict(self.image_processor_dict       )
             self.assertEqual(image_processor.size					,      {"shortest_edge": 18, "longest_edge": 1333}       )
             self.assertEqual(image_processor.do_pad					,      __lowerCamelCase       )





       def 						lowerCAmelCase     (   self							:			List[str]       ):


             '''simple docstring'''



             pass





       def 						lowerCAmelCase     (   self							:			Optional[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[int]    =  self.image_processing_class(**self.image_processor_dict       )
             # create random PIL images
             lowerCamelCase__		:				List[str]    =  prepare_image_inputs(self.image_processor_tester					,      equal_resolution=__lowerCamelCase       )
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase					,      Image.Image       )

             # Test not batched input
             lowerCamelCase__		:				Optional[int]    =  image_processing(image_inputs[0]					,      return_tensors="pt"       ).pixel_values

             lowerCamelCase__    ,   lowerCamelCase__		:				Optional[Any]    =  self.image_processor_tester.get_expected_values(__lowerCamelCase       )

             self.assertEqual(
                 encoded_images.shape					,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)					,      )

             # Test batched
             lowerCamelCase__    ,   lowerCamelCase__		:				List[str]    =  self.image_processor_tester.get_expected_values(__lowerCamelCase					,      batched=__lowerCamelCase       )

             lowerCamelCase__		:				List[Any]    =  image_processing(__lowerCamelCase					,      return_tensors="pt"       ).pixel_values
             self.assertEqual(
                 encoded_images.shape					,      (
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )					,      )





       def 						lowerCAmelCase     (   self							:			Any       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[int]    =  self.image_processing_class(**self.image_processor_dict       )
             # create random numpy tensors
             lowerCamelCase__		:				Optional[int]    =  prepare_image_inputs(self.image_processor_tester					,      equal_resolution=__lowerCamelCase					,      numpify=__lowerCamelCase       )
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase					,      np.ndarray       )

             # Test not batched input
             lowerCamelCase__		:				Any    =  image_processing(image_inputs[0]					,      return_tensors="pt"       ).pixel_values

             lowerCamelCase__    ,   lowerCamelCase__		:				Any    =  self.image_processor_tester.get_expected_values(__lowerCamelCase       )

             self.assertEqual(
                 encoded_images.shape					,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)					,      )

             # Test batched
             lowerCamelCase__		:				Optional[Any]    =  image_processing(__lowerCamelCase					,      return_tensors="pt"       ).pixel_values

             lowerCamelCase__    ,   lowerCamelCase__		:				Union[str, Any]    =  self.image_processor_tester.get_expected_values(__lowerCamelCase					,      batched=__lowerCamelCase       )

             self.assertEqual(
                 encoded_images.shape					,      (
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )					,      )





       def 						lowerCAmelCase     (   self							:			List[str]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Union[str, Any]    =  self.image_processing_class(**self.image_processor_dict       )
             # create random PyTorch tensors
             lowerCamelCase__		:				Dict    =  prepare_image_inputs(self.image_processor_tester					,      equal_resolution=__lowerCamelCase					,      torchify=__lowerCamelCase       )
             for image in image_inputs:
                   self.assertIsInstance(__lowerCamelCase					,      torch.Tensor       )

             # Test not batched input
             lowerCamelCase__		:				Dict    =  image_processing(image_inputs[0]					,      return_tensors="pt"       ).pixel_values

             lowerCamelCase__    ,   lowerCamelCase__		:				Any    =  self.image_processor_tester.get_expected_values(__lowerCamelCase       )

             self.assertEqual(
                 encoded_images.shape					,      (1, self.image_processor_tester.num_channels, expected_height, expected_width)					,      )

             # Test batched
             lowerCamelCase__		:				Union[str, Any]    =  image_processing(__lowerCamelCase					,      return_tensors="pt"       ).pixel_values

             lowerCamelCase__    ,   lowerCamelCase__		:				Dict    =  self.image_processor_tester.get_expected_values(__lowerCamelCase					,      batched=__lowerCamelCase       )

             self.assertEqual(
                 encoded_images.shape					,      (
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )					,      )





       @slow
       def 						lowerCAmelCase     (   self							:			Dict       ):


             '''simple docstring'''



             lowerCamelCase__		:				int    =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
             with open("./tests/fixtures/tests_samples/COCO/coco_annotations.txt"					,      "r"       ) as f:
                   lowerCamelCase__		:				Dict    =  json.loads(f.read()       )

             lowerCamelCase__		:				Any    =  {"image_id": 39769, "annotations": target}

             # encode them
             lowerCamelCase__		:				Union[str, Any]    =  DetaImageProcessor()
             lowerCamelCase__		:				List[str]    =  image_processing(images=__lowerCamelCase					,      annotations=__lowerCamelCase					,      return_tensors="pt"       )

             # verify pixel values
             lowerCamelCase__		:				List[str]    =  torch.Size([1, 3, 800, 1066]       )
             self.assertEqual(encoding["pixel_values"].shape					,      __lowerCamelCase       )

             lowerCamelCase__		:				Union[str, Any]    =  torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]       )
             self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]					,      __lowerCamelCase					,      atol=1E-4       )       )

             # verify area
             lowerCamelCase__		:				Tuple    =  torch.tensor([5_8_8_7.9_6_0_0, 1_1_2_5_0.2_0_6_1, 4_8_9_3_5_3.8_4_3_8, 8_3_7_1_2_2.7_5_0_0, 1_4_7_9_6_7.5_1_5_6, 1_6_5_7_3_2.3_4_3_8]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["area"]					,      __lowerCamelCase       )       )
             # verify boxes
             lowerCamelCase__		:				Union[str, Any]    =  torch.Size([6, 4]       )
             self.assertEqual(encoding["labels"][0]["boxes"].shape					,      __lowerCamelCase       )
             lowerCamelCase__		:				List[Any]    =  torch.tensor([0.5_5_0_3, 0.2_7_6_5, 0.0_6_0_4, 0.2_2_1_5]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]					,      __lowerCamelCase					,      atol=1E-3       )       )
             # verify image_id
             lowerCamelCase__		:				Optional[Any]    =  torch.tensor([39769]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]					,      __lowerCamelCase       )       )
             # verify is_crowd
             lowerCamelCase__		:				Dict    =  torch.tensor([0, 0, 0, 0, 0, 0]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]					,      __lowerCamelCase       )       )
             # verify class_labels
             lowerCamelCase__		:				int    =  torch.tensor([75, 75, 63, 65, 17, 17]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]					,      __lowerCamelCase       )       )
             # verify orig_size
             lowerCamelCase__		:				int    =  torch.tensor([480, 640]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]					,      __lowerCamelCase       )       )
             # verify size
             lowerCamelCase__		:				Optional[int]    =  torch.tensor([800, 1066]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["size"]					,      __lowerCamelCase       )       )





       @slow
       def 						lowerCAmelCase     (   self							:			Optional[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Union[str, Any]    =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"       )
             with open("./tests/fixtures/tests_samples/COCO/coco_panoptic_annotations.txt"					,      "r"       ) as f:
                   lowerCamelCase__		:				Tuple    =  json.loads(f.read()       )

             lowerCamelCase__		:				List[str]    =  {"file_name": "000000039769.png", "image_id": 39769, "segments_info": target}

             lowerCamelCase__		:				Union[str, Any]    =  pathlib.Path("./tests/fixtures/tests_samples/COCO/coco_panoptic"       )

             # encode them
             lowerCamelCase__		:				Tuple    =  DetaImageProcessor(format="coco_panoptic"       )
             lowerCamelCase__		:				Dict    =  image_processing(images=__lowerCamelCase					,      annotations=__lowerCamelCase					,      masks_path=__lowerCamelCase					,      return_tensors="pt"       )

             # verify pixel values
             lowerCamelCase__		:				List[Any]    =  torch.Size([1, 3, 800, 1066]       )
             self.assertEqual(encoding["pixel_values"].shape					,      __lowerCamelCase       )

             lowerCamelCase__		:				Dict    =  torch.tensor([0.2_7_9_6, 0.3_1_3_8, 0.3_4_8_1]       )
             self.assertTrue(torch.allclose(encoding["pixel_values"][0, 0, 0, :3]					,      __lowerCamelCase					,      atol=1E-4       )       )

             # verify area
             lowerCamelCase__		:				List[Any]    =  torch.tensor([1_4_7_9_7_9.6_8_7_5, 1_6_5_5_2_7.0_4_6_9, 4_8_4_6_3_8.5_9_3_8, 1_1_2_9_2.9_3_7_5, 5_8_7_9.6_5_6_2, 7_6_3_4.1_1_4_7]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["area"]					,      __lowerCamelCase       )       )
             # verify boxes
             lowerCamelCase__		:				Any    =  torch.Size([6, 4]       )
             self.assertEqual(encoding["labels"][0]["boxes"].shape					,      __lowerCamelCase       )
             lowerCamelCase__		:				int    =  torch.tensor([0.2_6_2_5, 0.5_4_3_7, 0.4_6_8_8, 0.8_6_2_5]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["boxes"][0]					,      __lowerCamelCase					,      atol=1E-3       )       )
             # verify image_id
             lowerCamelCase__		:				Optional[int]    =  torch.tensor([39769]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["image_id"]					,      __lowerCamelCase       )       )
             # verify is_crowd
             lowerCamelCase__		:				Dict    =  torch.tensor([0, 0, 0, 0, 0, 0]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["iscrowd"]					,      __lowerCamelCase       )       )
             # verify class_labels
             lowerCamelCase__		:				Tuple    =  torch.tensor([17, 17, 63, 75, 75, 93]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["class_labels"]					,      __lowerCamelCase       )       )
             # verify masks
             lowerCamelCase__		:				Union[str, Any]    =  822873
             self.assertEqual(encoding["labels"][0]["masks"].sum().item()					,      __lowerCamelCase       )
             # verify orig_size
             lowerCamelCase__		:				Optional[Any]    =  torch.tensor([480, 640]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["orig_size"]					,      __lowerCamelCase       )       )
             # verify size
             lowerCamelCase__		:				Union[str, Any]    =  torch.tensor([800, 1066]       )
             self.assertTrue(torch.allclose(encoding["labels"][0]["size"]					,      __lowerCamelCase       )       )


