



"""simple docstring"""





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowerCamelCase  			=		logging.get_logger(__name__)
def   a__      ( lowerCAmelCase__ ):
      UpperCAmelCase_     					=				SwinConfig(
          embed_dim=192      ,     depths=(2, 2, 18, 2)      ,     num_heads=(6, 12, 24, 48)      ,     window_size=12      ,     out_features=["stage2", "stage3", "stage4"]      ,     )

      UpperCAmelCase_     					=				DetaConfig(
          backbone_config=lowerCAmelCase__      ,     num_queries=900      ,     encoder_ffn_dim=2048      ,     decoder_ffn_dim=2048      ,     num_feature_levels=5      ,     assign_first_stage=lowerCAmelCase__      ,     with_box_refine=lowerCAmelCase__      ,     two_stage=lowerCAmelCase__      ,     )

      # set labels
      UpperCAmelCase_     					=				"huggingface/label-files"
      if "o365" in model_name:
            UpperCAmelCase_     					=				366
            UpperCAmelCase_     					=				"object365-id2label.json"
      else:
            UpperCAmelCase_     					=				91
            UpperCAmelCase_     					=				"coco-detection-id2label.json"

      UpperCAmelCase_     					=				num_labels
      UpperCAmelCase_     					=				json.load(open(cached_download(hf_hub_url(lowerCAmelCase__      ,     lowerCAmelCase__      ,     repo_type="dataset" ) )      ,     "r" ) )
      UpperCAmelCase_     					=				{int(lowerCAmelCase__ ): v for k, v in idalabel.items()}
      UpperCAmelCase_     					=				idalabel
      UpperCAmelCase_     					=				{v: k for k, v in idalabel.items()}

      return config
def   a__      ( lowerCAmelCase__ ):
      UpperCAmelCase_     					=				[]

      # stem
      # fmt: off
      rename_keys.append(("backbone.0.body.patch_embed.proj.weight", "model.backbone.model.embeddings.patch_embeddings.projection.weight") )
      rename_keys.append(("backbone.0.body.patch_embed.proj.bias", "model.backbone.model.embeddings.patch_embeddings.projection.bias") )
      rename_keys.append(("backbone.0.body.patch_embed.norm.weight", "model.backbone.model.embeddings.norm.weight") )
      rename_keys.append(("backbone.0.body.patch_embed.norm.bias", "model.backbone.model.embeddings.norm.bias") )
      # stages
      for i in range(len(config.backbone_config.depths ) ):
            for j in range(config.backbone_config.depths[i] ):
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.norm2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias""", f"""model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias""") )

            if i < 3:
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.reduction.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.reduction.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.weight""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.weight""") )
                  rename_keys.append((f"""backbone.0.body.layers.{i}.downsample.norm.bias""", f"""model.backbone.model.encoder.layers.{i}.downsample.norm.bias""") )

      rename_keys.append(("backbone.0.body.norm1.weight", "model.backbone.model.hidden_states_norms.stage2.weight") )
      rename_keys.append(("backbone.0.body.norm1.bias", "model.backbone.model.hidden_states_norms.stage2.bias") )
      rename_keys.append(("backbone.0.body.norm2.weight", "model.backbone.model.hidden_states_norms.stage3.weight") )
      rename_keys.append(("backbone.0.body.norm2.bias", "model.backbone.model.hidden_states_norms.stage3.bias") )
      rename_keys.append(("backbone.0.body.norm3.weight", "model.backbone.model.hidden_states_norms.stage4.weight") )
      rename_keys.append(("backbone.0.body.norm3.bias", "model.backbone.model.hidden_states_norms.stage4.bias") )

      # transformer encoder
      for i in range(config.encoder_layers ):
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias""", f"""model.encoder.layers.{i}.self_attn.sampling_offsets.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.weight""", f"""model.encoder.layers.{i}.self_attn.attention_weights.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.attention_weights.bias""", f"""model.encoder.layers.{i}.self_attn.attention_weights.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.weight""", f"""model.encoder.layers.{i}.self_attn.value_proj.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.value_proj.bias""", f"""model.encoder.layers.{i}.self_attn.value_proj.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.weight""", f"""model.encoder.layers.{i}.self_attn.output_proj.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.self_attn.output_proj.bias""", f"""model.encoder.layers.{i}.self_attn.output_proj.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.weight""", f"""model.encoder.layers.{i}.self_attn_layer_norm.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm1.bias""", f"""model.encoder.layers.{i}.self_attn_layer_norm.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.weight""", f"""model.encoder.layers.{i}.fc1.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear1.bias""", f"""model.encoder.layers.{i}.fc1.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.weight""", f"""model.encoder.layers.{i}.fc2.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.linear2.bias""", f"""model.encoder.layers.{i}.fc2.bias""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.weight""", f"""model.encoder.layers.{i}.final_layer_norm.weight""") )
            rename_keys.append((f"""transformer.encoder.layers.{i}.norm2.bias""", f"""model.encoder.layers.{i}.final_layer_norm.bias""") )

      # transformer decoder
      for i in range(config.decoder_layers ):
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias""", f"""model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.weight""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.attention_weights.bias""", f"""model.decoder.layers.{i}.encoder_attn.attention_weights.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.value_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.value_proj.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.weight""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.cross_attn.output_proj.bias""", f"""model.decoder.layers.{i}.encoder_attn.output_proj.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.weight""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm1.bias""", f"""model.decoder.layers.{i}.encoder_attn_layer_norm.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", f"""model.decoder.layers.{i}.self_attn.out_proj.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", f"""model.decoder.layers.{i}.self_attn.out_proj.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.weight""", f"""model.decoder.layers.{i}.self_attn_layer_norm.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm2.bias""", f"""model.decoder.layers.{i}.self_attn_layer_norm.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.weight""", f"""model.decoder.layers.{i}.fc1.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear1.bias""", f"""model.decoder.layers.{i}.fc1.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.weight""", f"""model.decoder.layers.{i}.fc2.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.linear2.bias""", f"""model.decoder.layers.{i}.fc2.bias""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.weight""", f"""model.decoder.layers.{i}.final_layer_norm.weight""") )
            rename_keys.append((f"""transformer.decoder.layers.{i}.norm3.bias""", f"""model.decoder.layers.{i}.final_layer_norm.bias""") )

      # fmt: on

      return rename_keys
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__ ):
      UpperCAmelCase_     					=				dct.pop(lowerCAmelCase__ )
      UpperCAmelCase_     					=				val
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__ ):
      UpperCAmelCase_     					=				[int(backbone_config.embed_dim * 2**i ) for i in range(len(backbone_config.depths ) )]
      for i in range(len(backbone_config.depths ) ):
            UpperCAmelCase_     					=				num_features[i]
            for j in range(backbone_config.depths[i] ):
                  # fmt: off
                  # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
                  UpperCAmelCase_     					=				state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight""" )
                  UpperCAmelCase_     					=				state_dict.pop(f"""backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias""" )
                  # next, add query, keys and values (in that order) to the state dict
                  UpperCAmelCase_     					=				in_proj_weight[:dim, :]
                  UpperCAmelCase_     					=				in_proj_bias[: dim]
                  UpperCAmelCase_     					=				in_proj_weight[
                      dim : dim * 2, :
                  ]
                  UpperCAmelCase_     					=				in_proj_bias[
                      dim : dim * 2
                  ]
                  UpperCAmelCase_     					=				in_proj_weight[
                      -dim :, :
                  ]
                  UpperCAmelCase_     					=				in_proj_bias[-dim :]
                  # fmt: on
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__ ):
      # transformer decoder self-attention layers
      UpperCAmelCase_     					=				config.d_model
      for i in range(config.decoder_layers ):
            # read in weights + bias of input projection layer of self-attention
            UpperCAmelCase_     					=				state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_weight""" )
            UpperCAmelCase_     					=				state_dict.pop(f"""transformer.decoder.layers.{i}.self_attn.in_proj_bias""" )
            # next, add query, keys and values (in that order) to the state dict
            UpperCAmelCase_     					=				in_proj_weight[:hidden_size, :]
            UpperCAmelCase_     					=				in_proj_bias[:hidden_size]
            UpperCAmelCase_     					=				in_proj_weight[
                hidden_size : hidden_size * 2, :
            ]
            UpperCAmelCase_     					=				in_proj_bias[hidden_size : hidden_size * 2]
            UpperCAmelCase_     					=				in_proj_weight[-hidden_size:, :]
            UpperCAmelCase_     					=				in_proj_bias[-hidden_size:]
def   a__      ( ):
      UpperCAmelCase_     					=				"http://images.cocodataset.org/val2017/000000039769.jpg"
      UpperCAmelCase_     					=				Image.open(requests.get(lowerCAmelCase__      ,     stream=lowerCAmelCase__ ).raw )

      return im
@torch.no_grad()
def   a__      ( lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__ ):
      UpperCAmelCase_     					=				get_deta_config(lowerCAmelCase__ )

      # load original state dict
      if model_name == "deta-swin-large":
            UpperCAmelCase_     					=				hf_hub_download(repo_id="nielsr/deta-checkpoints"      ,     filename="adet_swin_ft.pth" )
      elif model_name == "deta-swin-large-o365":
            UpperCAmelCase_     					=				hf_hub_download(repo_id="jozhang97/deta-swin-l-o365"      ,     filename="deta_swin_pt_o365.pth" )
      else:
            raise ValueError(f"""Model name {model_name} not supported""" )

      UpperCAmelCase_     					=				torch.load(lowerCAmelCase__      ,     map_location="cpu" )["model"]

      # original state dict
      for name, param in state_dict.items():
            print(lowerCAmelCase__      ,     param.shape )

      # rename keys
      UpperCAmelCase_     					=				create_rename_keys(lowerCAmelCase__ )
      for src, dest in rename_keys:
            rename_key(lowerCAmelCase__      ,     lowerCAmelCase__      ,     lowerCAmelCase__ )
      read_in_swin_q_k_v(lowerCAmelCase__      ,     config.backbone_config )
      read_in_decoder_q_k_v(lowerCAmelCase__      ,     lowerCAmelCase__ )

      # fix some prefixes
      for key in state_dict.copy().keys():
            if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
                  UpperCAmelCase_     					=				state_dict.pop(lowerCAmelCase__ )
                  UpperCAmelCase_     					=				val
            if "input_proj" in key:
                  UpperCAmelCase_     					=				state_dict.pop(lowerCAmelCase__ )
                  UpperCAmelCase_     					=				val
            if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
                  UpperCAmelCase_     					=				state_dict.pop(lowerCAmelCase__ )
                  UpperCAmelCase_     					=				val

    # finally, create HuggingFace model and load state dict
      UpperCAmelCase_     					=				DetaForObjectDetection(lowerCAmelCase__ )
      model.load_state_dict(lowerCAmelCase__ )
      model.eval()

      UpperCAmelCase_     					=				"cuda" if torch.cuda.is_available() else "cpu"
      model.to(lowerCAmelCase__ )

      # load image processor
      UpperCAmelCase_     					=				DetaImageProcessor(format="coco_detection" )

      # verify our conversion on image
      UpperCAmelCase_     					=				prepare_img()
      UpperCAmelCase_     					=				processor(images=lowerCAmelCase__      ,     return_tensors="pt" )
      UpperCAmelCase_     					=				encoding["pixel_values"]
      UpperCAmelCase_     					=				model(pixel_values.to(lowerCAmelCase__ ) )

      # verify logits
      print("Logits:"      ,     outputs.logits[0, :3, :3] )
      print("Boxes:"      ,     outputs.pred_boxes[0, :3, :3] )
      if model_name == "deta-swin-large":
            UpperCAmelCase_     					=				torch.tensor(
                [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]] )
            UpperCAmelCase_     					=				torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]] )
      elif model_name == "deta-swin-large-o365":
            UpperCAmelCase_     					=				torch.tensor(
                [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]] )
            UpperCAmelCase_     					=				torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]] )
      assert torch.allclose(outputs.logits[0, :3, :3]      ,     expected_logits.to(lowerCAmelCase__ )      ,     atol=1e-4 )
      assert torch.allclose(outputs.pred_boxes[0, :3, :3]      ,     expected_boxes.to(lowerCAmelCase__ )      ,     atol=1e-4 )
      print("Everything ok!" )

      if pytorch_dump_folder_path:
            # Save model and processor
            logger.info(f"""Saving PyTorch model and processor to {pytorch_dump_folder_path}...""" )
            Path(lowerCAmelCase__ ).mkdir(exist_ok=lowerCAmelCase__ )
            model.save_pretrained(lowerCAmelCase__ )
            processor.save_pretrained(lowerCAmelCase__ )

      # Push to hub
      if push_to_hub:
            print("Pushing model and processor to hub..." )
            model.push_to_hub(f"""jozhang97/{model_name}""" )
            processor.push_to_hub(f"""jozhang97/{model_name}""" )


if __name__ == "__main__":
  lowerCamelCase  			=		argparse.ArgumentParser()

  parser.add_argument(
      """--model_name""",
      type=str,
      default="""deta-swin-large""",
      choices=["""deta-swin-large""", """deta-swin-large-o365"""],
      help="""Name of the model you'd like to convert.""",
  )
  parser.add_argument(
      """--pytorch_dump_folder_path""",
      default=None,
      type=str,
      help="""Path to the folder to output PyTorch model.""",
  )
  parser.add_argument(
      """--push_to_hub""", action="""store_true""", help="""Whether or not to push the converted model to the 🤗 hub."""
  )
  lowerCamelCase  			=		parser.parse_args()
  convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import copy
import inspect
import unittest

from transformers import PretrainedConfig, SwiftFormerConfig
from transformers.testing_utils import (
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import SwiftFormerForImageClassification, SwiftFormerModel
 from transformers.models.swiftformer.modeling_swiftformer import SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor






class 	__lowercase					:





      def __init__(		self    :       Optional[Any]       ,							__lowerCamelCase    :       Any       ,							__lowerCamelCase    :       int=1_3       ,							__lowerCamelCase    :       List[str]=3       ,							__lowerCamelCase    :       List[str]=True       ,							__lowerCamelCase    :       Any=True       ,							__lowerCamelCase    :       Optional[int]=0.1       ,							__lowerCamelCase    :       Optional[Any]=0.1       ,							__lowerCamelCase    :       Tuple=2_2_4       ,							__lowerCamelCase    :       int=1_0_0_0       ,							__lowerCamelCase    :       int=[3, 3, 6, 4]       ,							__lowerCamelCase    :       Dict=[4_8, 5_6, 1_1_2, 2_2_0]       ,							)     -> Union[str, Any]:






         """simple docstring"""







         UpperCAmelCase      					=  parent
         UpperCAmelCase      					=  batch_size
         UpperCAmelCase      					=  num_channels
         UpperCAmelCase      					=  is_training
         UpperCAmelCase      					=  use_labels
         UpperCAmelCase      					=  hidden_dropout_prob
         UpperCAmelCase      					=  attention_probs_dropout_prob
         UpperCAmelCase      					=  num_labels
         UpperCAmelCase      					=  image_size
         UpperCAmelCase      					=  layer_depths
         UpperCAmelCase      					=  embed_dims





      def 							_lowercase					(		self    :       List[str]							)     -> Optional[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

         UpperCAmelCase      					=  None
         if self.use_labels:
            UpperCAmelCase      					=  ids_tensor([self.batch_size]       ,							self.num_labels							)

         UpperCAmelCase      					=  self.get_config()

         return config, pixel_values, labels





      def 							_lowercase					(		self    :       Optional[Any]							)     -> str:






         """simple docstring"""







         return SwiftFormerConfig(
             depths=self.layer_depths       ,							embed_dims=self.embed_dims       ,							mlp_ratio=4       ,							downsamples=[True, True, True, True]       ,							hidden_act="""gelu"""       ,							num_labels=self.num_labels       ,							down_patch_size=3       ,							down_stride=2       ,							down_pad=1       ,							drop_rate=0.0       ,							drop_path_rate=0.0       ,							use_layer_scale=__lowerCamelCase       ,							layer_scale_init_value=1e-5       ,							)





      def 							_lowercase					(		self    :       Tuple       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Optional[int]							)     -> str:






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerModel(config=__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()
         UpperCAmelCase      					=  model(__lowerCamelCase							)
         self.parent.assertEqual(result.last_hidden_state.shape       ,							(self.batch_size, self.embed_dims[-1], 7, 7)							)





      def 							_lowercase					(		self    :       List[str]       ,							__lowerCamelCase    :       int       ,							__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Any							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  self.num_labels
         UpperCAmelCase      					=  SwiftFormerForImageClassification(__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()
         UpperCAmelCase      					=  model(__lowerCamelCase       ,							labels=__lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)							)

         UpperCAmelCase      					=  SwiftFormerForImageClassification(__lowerCamelCase							)
         model.to(__lowerCamelCase							)
         model.eval()

         UpperCAmelCase      					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)
         UpperCAmelCase      					=  model(__lowerCamelCase							)
         self.parent.assertEqual(result.logits.shape       ,							(self.batch_size, self.num_labels)							)





      def 							_lowercase					(		self    :       Tuple							)     -> Optional[Any]:






         """simple docstring"""







         ((UpperCAmelCase)					,	(UpperCAmelCase)					,	(UpperCAmelCase))      					=  self.prepare_config_and_inputs()
         UpperCAmelCase      					=  {"""pixel_values""": pixel_values}
         return config, inputs_dict






@require_torch
class 	__lowercase					(	__snake_case			,       __snake_case			,       unittest.TestCase	):
      UpperCamelCase										=							(SwiftFormerModel, SwiftFormerForImageClassification) if is_torch_available() else ()
      UpperCamelCase										=							(
          {'''feature-extraction''': SwiftFormerModel, '''image-classification''': SwiftFormerForImageClassification}
          if is_torch_available()
          else {}
      )

      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False
      UpperCamelCase										=							False





      def 							_lowercase					(		self    :       str							)     -> Tuple:






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerModelTester(self							)
         UpperCAmelCase      					=  ConfigTester(
             self       ,							config_class=__lowerCamelCase       ,							has_text_modality=__lowerCamelCase       ,							hidden_size=3_7       ,							num_attention_heads=1_2       ,							num_hidden_layers=1_2       ,							)





      def 							_lowercase					(		self    :       Dict							)     -> Union[str, Any]:






         """simple docstring"""







         self.config_tester.run_common_tests()





      @unittest.skip(reason="""SwiftFormer does not use inputs_embeds"""							)
      def 							_lowercase					(		self    :       Optional[int]							)     -> List[str]:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       str							)     -> str:






         """simple docstring"""







         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            UpperCAmelCase      					=  model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(__lowerCamelCase       ,							nn.Linear							)							)





      def 							_lowercase					(		self    :       Union[str, Any]							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            UpperCAmelCase      					=  inspect.signature(model.forward							)
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            UpperCAmelCase      					=  [*signature.parameters.keys()]

            UpperCAmelCase      					=  ["""pixel_values"""]
            self.assertListEqual(arg_names[:1]       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       List[str]							)     -> Dict:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__lowerCamelCase							)





      def 							_lowercase					(		self    :       Optional[Any]							)     -> List[Any]:






         """simple docstring"""







         UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase							)





      @slow
      def 							_lowercase					(		self    :       Optional[Any]							)     -> Optional[Any]:






         """simple docstring"""







         for model_name in SWIFTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            UpperCAmelCase      					=  SwiftFormerModel.from_pretrained(__lowerCamelCase							)
            self.assertIsNotNone(__lowerCamelCase							)





      @unittest.skip(reason="""SwiftFormer does not output attentions"""							)
      def 							_lowercase					(		self    :       List[str]							)     -> Union[str, Any]:






         """simple docstring"""







         pass





      def 							_lowercase					(		self    :       Dict							)     -> List[Any]:






         """simple docstring"""







         def check_hidden_states_output(__lowerCamelCase    :       List[str]       ,							__lowerCamelCase    :       Dict       ,							__lowerCamelCase    :       Optional[Any]							):
            UpperCAmelCase      					=  model_class(__lowerCamelCase							)
            model.to(__lowerCamelCase							)
            model.eval()

            with torch.no_grad():
               UpperCAmelCase      					=  model(**self._prepare_for_class(__lowerCamelCase       ,							__lowerCamelCase							)							)

            UpperCAmelCase      					=  outputs.hidden_states

            UpperCAmelCase      					=  8
            self.assertEqual(len(__lowerCamelCase							)       ,							__lowerCamelCase							)  # TODO

            # SwiftFormer's feature maps are of shape (batch_size, embed_dims, height, width)
            # with the width and height being successively divided by 2, after every 2 blocks
            for i in range(len(__lowerCamelCase							)							):
               self.assertEqual(
                   hidden_states[i].shape       ,							torch.Size(
                       [
                           self.model_tester.batch_size,
                           self.model_tester.embed_dims[i // 2],
                           (self.model_tester.image_size // 4) // 2 ** (i // 2),
                           (self.model_tester.image_size // 4) // 2 ** (i // 2),
                       ]							)       ,							)

         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  True
            check_hidden_states_output(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)

            # check that output_hidden_states also work using config
            del inputs_dict["output_hidden_states"]
            UpperCAmelCase      					=  True

            check_hidden_states_output(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)





      def 							_lowercase					(		self    :       Dict							)     -> Union[str, Any]:






         """simple docstring"""







         def _config_zero_init(__lowerCamelCase    :       Any							):
            UpperCAmelCase      					=  copy.deepcopy(__lowerCamelCase							)
            for key in configs_no_init.__dict__.keys():
               if "_range" in key or "_std" in key or "initializer_factor" in key or "layer_scale" in key:
                  setattr(__lowerCamelCase       ,							__lowerCamelCase       ,							1e-1_0							)
               if isinstance(getattr(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)       ,							__lowerCamelCase							):
                  UpperCAmelCase      					=  _config_zero_init(getattr(__lowerCamelCase       ,							__lowerCamelCase							)							)
                  setattr(__lowerCamelCase       ,							__lowerCamelCase       ,							__lowerCamelCase							)
            return configs_no_init

         UpperCAmelCase					,	UpperCAmelCase      					=  self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase      					=  _config_zero_init(__lowerCamelCase							)
         for model_class in self.all_model_classes:
            UpperCAmelCase      					=  model_class(config=__lowerCamelCase							)
            for name, param in model.named_parameters():
               if param.requires_grad:
                  self.assertIn(
                      ((param.data.mean() * 1e9) / 1e9).round().item()       ,							[0.0, 1.0]       ,							msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""       ,							)





      @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""							)
      def 							_lowercase					(		self    :       Optional[int]							)     -> List[str]:






         """simple docstring"""







         pass

def 	_UpperCamelCase					(    )    ->Dict:
   UpperCAmelCase      					=  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
   return image







@require_torch
@require_vision
class 	__lowercase					(	unittest.TestCase	):





      @cached_property
      def 							_lowercase					(		self    :       Optional[int]							)     -> int:






         """simple docstring"""







         return ViTImageProcessor.from_pretrained("""MBZUAI/swiftformer-xs"""							) if is_vision_available() else None





      @slow
      def 							_lowercase					(		self    :       Optional[int]							)     -> Any:






         """simple docstring"""







         UpperCAmelCase      					=  SwiftFormerForImageClassification.from_pretrained("""MBZUAI/swiftformer-xs"""							).to(__lowerCamelCase							)

         UpperCAmelCase      					=  self.default_image_processor
         UpperCAmelCase      					=  prepare_img()
         UpperCAmelCase      					=  image_processor(images=__lowerCamelCase       ,							return_tensors="""pt"""							).to(__lowerCamelCase							)

         # forward pass
         with torch.no_grad():
            UpperCAmelCase      					=  model(**__lowerCamelCase							)

         # verify the logits
         UpperCAmelCase      					=  torch.Size((1, 1_0_0_0)							)
         self.assertEqual(outputs.logits.shape       ,							__lowerCamelCase							)

         UpperCAmelCase      					=  torch.tensor([[-2.1_7_0_3e0_0, 2.1_1_0_7e0_0, -2.0_8_1_1e0_0]]							).to(__lowerCamelCase							)
         self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,							__lowerCamelCase       ,							atol=1e-4							)							)



