






'''simple docstring'''

import argparse
import json
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from typing import List

import timm
import torch
import torch.nn as nn
from huggingface_hub import hf_hub_download
from torch import Tensor

from transformers import AutoImageProcessor, ResNetConfig, ResNetForImageClassification
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE__     =       logging.get_logger()






@dataclass
class     a_						:
  lowercase							=				42
  lowercase							=				field(default_factory=lowerCamelCase    )
  lowercase							=				field(default_factory=lowerCamelCase    )

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				int:



        """simple docstring"""






        UpperCamelCase      = len(list(m.modules()				)				) == 1 or isinstance(_SCREAMING_SNAKE_CASE      ,		nn.Convad				) or isinstance(_SCREAMING_SNAKE_CASE      ,		nn.BatchNormad				)
        if has_not_submodules:
              self.traced.append(_SCREAMING_SNAKE_CASE				)

  def __call__(				self      ,		_SCREAMING_SNAKE_CASE				)  ->				Any:



        """simple docstring"""






        for m in self.module.modules():
              self.handles.append(m.register_forward_hook(self._forward_hook				)				)
        self.module(_SCREAMING_SNAKE_CASE				)
        [x.remove() for x in self.handles]
        return self


  @property
  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        return list(filter(lambda _SCREAMING_SNAKE_CASE				: len(list(x.state_dict().keys()				)				) > 0      ,		self.traced				)				)






@dataclass
class     a_						:
  lowercase							=				42
  lowercase							=				42
  lowercase							=				0
  lowercase							=				field(default_factory=lowerCamelCase    )
  lowercase							=				field(default_factory=lowerCamelCase    )

  def __call__(				self      ,		_SCREAMING_SNAKE_CASE				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = Tracker(self.dest				)(_SCREAMING_SNAKE_CASE				).parametrized
        UpperCamelCase      = Tracker(self.src				)(_SCREAMING_SNAKE_CASE				).parametrized

        UpperCamelCase      = list(filter(lambda _SCREAMING_SNAKE_CASE				: type(_SCREAMING_SNAKE_CASE				) not in self.src_skip      ,		_SCREAMING_SNAKE_CASE				)				)
        UpperCamelCase      = list(filter(lambda _SCREAMING_SNAKE_CASE				: type(_SCREAMING_SNAKE_CASE				) not in self.dest_skip      ,		_SCREAMING_SNAKE_CASE				)				)

        if len(_SCREAMING_SNAKE_CASE				) != len(_SCREAMING_SNAKE_CASE				):
              raise Exception(
                  F"Numbers of operations are different. Source module has {len(_SCREAMING_SNAKE_CASE				)} operations while"
                  F" destination module has {len(_SCREAMING_SNAKE_CASE				)}."				)

        for dest_m, src_m in zip(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				):
              dest_m.load_state_dict(src_m.state_dict()				)
              if self.verbose == 1:
                    print(F"Transfered from={src_m} to={dest_m}"				)







def    lowercase__			(				__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase = True   )->			Optional[Any]:
      print(F"Converting {name}..."   )
      with torch.no_grad():
            UpperCamelCase      = timm.create_model(__UpperCamelCase		,						pretrained=__UpperCamelCase   ).eval()
            UpperCamelCase      = ResNetForImageClassification(__UpperCamelCase   ).eval()
            UpperCamelCase      = ModuleTransfer(src=__UpperCamelCase		,						dest=__UpperCamelCase   )
            UpperCamelCase      = torch.randn((1, 3, 224, 224)   )
            module_transfer(__UpperCamelCase   )

      assert torch.allclose(from_model(__UpperCamelCase   )		,						our_model(__UpperCamelCase   ).logits   ), "The model logits don't match the original one."

      UpperCamelCase      = F"resnet{'-'.join(name.split('resnet'   )   )}"
      print(__UpperCamelCase   )

      if push_to_hub:
            our_model.push_to_hub(
                repo_path_or_name=save_directory / checkpoint_name		,						commit_message="""Add model"""		,						use_temp_dir=__UpperCamelCase		,						)

            # we can use the convnext one
            UpperCamelCase      = AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k"""   )
            image_processor.push_to_hub(
                repo_path_or_name=save_directory / checkpoint_name		,						commit_message="""Add image processor"""		,						use_temp_dir=__UpperCamelCase		,						)

            print(F"Pushed {checkpoint_name}"   )







def    lowercase__			(				__UpperCamelCase		,						__UpperCamelCase = None		,						__UpperCamelCase = True   )->			str:
      UpperCamelCase      = """imagenet-1k-id2label.json"""
      UpperCamelCase      = 1000
      UpperCamelCase      = (1, num_labels)

      UpperCamelCase      = """huggingface/label-files"""
      UpperCamelCase      = num_labels
      UpperCamelCase      = json.load(open(hf_hub_download(__UpperCamelCase		,						__UpperCamelCase		,						repo_type="""dataset"""   )		,						"""r"""   )   )
      UpperCamelCase      = {int(__UpperCamelCase   ): v for k, v in idalabel.items()}

      UpperCamelCase      = idalabel
      UpperCamelCase      = {v: k for k, v in idalabel.items()}

      UpperCamelCase      = partial(__UpperCamelCase		,						num_labels=__UpperCamelCase		,						idalabel=__UpperCamelCase		,						labelaid=__UpperCamelCase   )

      UpperCamelCase      = {
          """resnet18""": ImageNetPreTrainedConfig(
              depths=[2, 2, 2, 2]		,						hidden_sizes=[64, 128, 256, 512]		,						layer_type="""basic"""   ),
          """resnet26""": ImageNetPreTrainedConfig(
              depths=[2, 2, 2, 2]		,						hidden_sizes=[256, 512, 1024, 2048]		,						layer_type="""bottleneck"""   ),
          """resnet34""": ImageNetPreTrainedConfig(
              depths=[3, 4, 6, 3]		,						hidden_sizes=[64, 128, 256, 512]		,						layer_type="""basic"""   ),
          """resnet50""": ImageNetPreTrainedConfig(
              depths=[3, 4, 6, 3]		,						hidden_sizes=[256, 512, 1024, 2048]		,						layer_type="""bottleneck"""   ),
          """resnet101""": ImageNetPreTrainedConfig(
              depths=[3, 4, 23, 3]		,						hidden_sizes=[256, 512, 1024, 2048]		,						layer_type="""bottleneck"""   ),
          """resnet152""": ImageNetPreTrainedConfig(
              depths=[3, 8, 36, 3]		,						hidden_sizes=[256, 512, 1024, 2048]		,						layer_type="""bottleneck"""   ),
      }

      if model_name:
            convert_weight_and_push(__UpperCamelCase		,						names_to_config[model_name]		,						__UpperCamelCase		,						__UpperCamelCase   )
      else:
            for model_name, config in names_to_config.items():
                  convert_weight_and_push(__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase		,						__UpperCamelCase   )
      return config, expected_shape


if __name__ == "__main__":
     SCREAMING_SNAKE_CASE__     =       argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         '--model_name',
         default=None,
         type=str,
         help=(
             'The name of the model you wish to convert, it must be one of the supported resnet* architecture,'
             ' currently: resnet18,26,34,50,101,152. If `None`, all of them will the converted.'
         ),
     )
     parser.add_argument(
         '--pytorch_dump_folder_path',
         default=None,
         type=Path,
         required=True,
         help='Path to the output PyTorch model directory.',
     )
     parser.add_argument(
         '--push_to_hub',
         default=True,
         type=bool,
         required=False,
         help='If True, push model and image processor to the hub.',
     )

     SCREAMING_SNAKE_CASE__     =       parser.parse_args()
     SCREAMING_SNAKE_CASE__     =       args.pytorch_dump_folder_path
     pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
     convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)








'''simple docstring'''

import collections
import inspect
import unittest

from transformers import FocalNetConfig
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_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import (
         FocalNetBackbone,
         FocalNetForImageClassification,
         FocalNetForMaskedImageModeling,
         FocalNetModel,
     )
     from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor






class     a_						:

  def __init__(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=13      ,		_SCREAMING_SNAKE_CASE=32      ,		_SCREAMING_SNAKE_CASE=2      ,		_SCREAMING_SNAKE_CASE=3      ,		_SCREAMING_SNAKE_CASE=16      ,		_SCREAMING_SNAKE_CASE=[32, 64, 128]      ,		_SCREAMING_SNAKE_CASE=[1, 2, 1]      ,		_SCREAMING_SNAKE_CASE=[2, 2, 4]      ,		_SCREAMING_SNAKE_CASE=2      ,		_SCREAMING_SNAKE_CASE=2.0      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=0.0      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE="gelu"      ,		_SCREAMING_SNAKE_CASE=False      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=0.0_2      ,		_SCREAMING_SNAKE_CASE=1e-5      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=None      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=10      ,		_SCREAMING_SNAKE_CASE=8      ,		_SCREAMING_SNAKE_CASE=["stage1", "stage2"]      ,		_SCREAMING_SNAKE_CASE=[1, 2]      ,		)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = parent
        UpperCamelCase      = batch_size
        UpperCamelCase      = image_size
        UpperCamelCase      = patch_size
        UpperCamelCase      = num_channels
        UpperCamelCase      = embed_dim
        UpperCamelCase      = hidden_sizes
        UpperCamelCase      = depths
        UpperCamelCase      = num_heads
        UpperCamelCase      = window_size
        UpperCamelCase      = mlp_ratio
        UpperCamelCase      = qkv_bias
        UpperCamelCase      = hidden_dropout_prob
        UpperCamelCase      = attention_probs_dropout_prob
        UpperCamelCase      = drop_path_rate
        UpperCamelCase      = hidden_act
        UpperCamelCase      = use_absolute_embeddings
        UpperCamelCase      = patch_norm
        UpperCamelCase      = layer_norm_eps
        UpperCamelCase      = initializer_range
        UpperCamelCase      = is_training
        UpperCamelCase      = scope
        UpperCamelCase      = use_labels
        UpperCamelCase      = type_sequence_label_size
        UpperCamelCase      = encoder_stride
        UpperCamelCase      = out_features
        UpperCamelCase      = out_indices

  def   A__						(				self				)  ->				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.type_sequence_label_size				)

        UpperCamelCase      = self.get_config()

        return config, pixel_values, labels

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        return FocalNetConfig(
            image_size=self.image_size      ,		patch_size=self.patch_size      ,		num_channels=self.num_channels      ,		embed_dim=self.embed_dim      ,		hidden_sizes=self.hidden_sizes      ,		depths=self.depths      ,		num_heads=self.num_heads      ,		window_size=self.window_size      ,		mlp_ratio=self.mlp_ratio      ,		qkv_bias=self.qkv_bias      ,		hidden_dropout_prob=self.hidden_dropout_prob      ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,		drop_path_rate=self.drop_path_rate      ,		hidden_act=self.hidden_act      ,		use_absolute_embeddings=self.use_absolute_embeddings      ,		path_norm=self.patch_norm      ,		layer_norm_eps=self.layer_norm_eps      ,		initializer_range=self.initializer_range      ,		encoder_stride=self.encoder_stride      ,		out_features=self.out_features      ,		out_indices=self.out_indices      ,		)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = FocalNetModel(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)

        UpperCamelCase      = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
        UpperCamelCase      = int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

        self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, expected_seq_len, expected_dim)				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = FocalNetBackbone(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)

        # verify feature maps
        self.parent.assertEqual(len(result.feature_maps				)      ,		len(config.out_features				)				)
        self.parent.assertListEqual(list(result.feature_maps[0].shape				)      ,		[self.batch_size, self.image_size, 8, 8]				)

        # verify channels
        self.parent.assertEqual(len(model.channels				)      ,		len(config.out_features				)				)
        self.parent.assertListEqual(model.channels      ,		config.hidden_sizes[:-1]				)

        # verify backbone works with out_features=None
        UpperCamelCase      = None
        UpperCamelCase      = FocalNetBackbone(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)

        # verify feature maps
        self.parent.assertEqual(len(result.feature_maps				)      ,		1				)
        self.parent.assertListEqual(list(result.feature_maps[0].shape				)      ,		[self.batch_size, self.image_size * 2, 4, 4]				)

        # verify channels
        self.parent.assertEqual(len(model.channels				)      ,		1				)
        self.parent.assertListEqual(model.channels      ,		[config.hidden_sizes[-1]]				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = FocalNetForMaskedImageModeling(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(
            result.reconstruction.shape      ,		(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

        # test greyscale images
        UpperCamelCase      = 1
        UpperCamelCase      = FocalNetForMaskedImageModeling(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

        UpperCamelCase      = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.reconstruction.shape      ,		(self.batch_size, 1, self.image_size, self.image_size)				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = self.type_sequence_label_size
        UpperCamelCase      = FocalNetForImageClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)				)

        # test greyscale images
        UpperCamelCase      = 1
        UpperCamelCase      = FocalNetForImageClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

        UpperCamelCase      = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.type_sequence_label_size)				)


  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = self.prepare_config_and_inputs()

        UpperCamelCase  ,UpperCamelCase  ,UpperCamelCase      = config_and_inputs
        UpperCamelCase      = {"""pixel_values""": pixel_values}
        return config, inputs_dict






@require_torch
class     a_						(      lowerCamelCase     ,	lowerCamelCase     ,	unittest.TestCase    ):
  lowercase							=				(
      (
          FocalNetModel,
          FocalNetForImageClassification,
          FocalNetForMaskedImageModeling,
          FocalNetBackbone,
      )
      if is_torch_available()
      else ()
  )
  lowercase							=				(
      {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
      if is_torch_available()
      else {}
  )
  lowercase							=				False

  lowercase							=				False
  lowercase							=				False
  lowercase							=				False
  lowercase							=				False

  def   A__						(				self				)  ->				int:



        """simple docstring"""






        UpperCamelCase      = FocalNetModelTester(self				)
        UpperCamelCase      = ConfigTester(self      ,		config_class=_SCREAMING_SNAKE_CASE      ,		embed_dim=37      ,		has_text_modality=_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        self.create_and_test_config_common_properties()
        self.config_tester.create_and_test_config_to_json_string()
        self.config_tester.create_and_test_config_to_json_file()
        self.config_tester.create_and_test_config_from_and_save_pretrained()
        self.config_tester.create_and_test_config_with_num_labels()
        self.config_tester.check_config_can_be_init_without_params()
        self.config_tester.check_config_arguments_init()

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        return

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*_SCREAMING_SNAKE_CASE				)

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



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE				)

  @unittest.skip(reason="""FocalNet does not use inputs_embeds"""				)
  def   A__						(				self				)  ->				int:



        """simple docstring"""






        pass

  @unittest.skip(reason="""FocalNet does not use feedforward chunking"""				)
  def   A__						(				self				)  ->				int:



        """simple docstring"""






        pass

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes[:-1]:
              UpperCamelCase      = model_class(_SCREAMING_SNAKE_CASE				)
              self.assertIsInstance(model.get_input_embeddings()      ,		(nn.Module)				)
              UpperCamelCase      = model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(_SCREAMING_SNAKE_CASE      ,		nn.Linear				)				)

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes[:-1]:
              UpperCamelCase      = model_class(_SCREAMING_SNAKE_CASE				)
              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]      ,		_SCREAMING_SNAKE_CASE				)

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Dict:



        """simple docstring"""






        UpperCamelCase      = model_class(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

        with torch.no_grad():
              UpperCamelCase      = model(**self._prepare_for_class(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)				)

        UpperCamelCase      = outputs.hidden_states

        UpperCamelCase      = getattr(
            self.model_tester      ,		"""expected_num_hidden_layers"""      ,		len(self.model_tester.depths				) + 1				)
        self.assertEqual(len(_SCREAMING_SNAKE_CASE				)      ,		_SCREAMING_SNAKE_CASE				)

        # FocalNet has a different seq_length
        UpperCamelCase      = (
            config.patch_size
            if isinstance(config.patch_size      ,		collections.abc.Iterable				)
            else (config.patch_size, config.patch_size)
        )

        UpperCamelCase      = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]				)      ,		[num_patches, self.model_tester.embed_dim]      ,		)

        UpperCamelCase      = outputs.reshaped_hidden_states
        self.assertEqual(len(_SCREAMING_SNAKE_CASE				)      ,		_SCREAMING_SNAKE_CASE				)

        UpperCamelCase  ,UpperCamelCase  ,UpperCamelCase  ,UpperCamelCase      = reshaped_hidden_states[0].shape
        UpperCamelCase      = (
            reshaped_hidden_states[0].view(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		height * width				).permute(0      ,		2      ,		1				)
        )
        self.assertListEqual(
            list(reshaped_hidden_states.shape[-2:]				)      ,		[num_patches, self.model_tester.embed_dim]      ,		)

  def   A__						(				self				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

        UpperCamelCase      = (
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size      ,		collections.abc.Iterable				)
            else (self.model_tester.image_size, self.model_tester.image_size)
        )

        for model_class in self.all_model_classes[:-1]:
              UpperCamelCase      = True
              self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)

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

              self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase      = 3

        UpperCamelCase      = (
            self.model_tester.image_size
            if isinstance(self.model_tester.image_size      ,		collections.abc.Iterable				)
            else (self.model_tester.image_size, self.model_tester.image_size)
        )
        UpperCamelCase      = (
            config.patch_size
            if isinstance(config.patch_size      ,		collections.abc.Iterable				)
            else (config.patch_size, config.patch_size)
        )

        UpperCamelCase      = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
        UpperCamelCase      = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

        for model_class in self.all_model_classes[:-1]:
              UpperCamelCase      = True
              self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		(padded_height, padded_width)				)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              UpperCamelCase      = True
              self.check_hidden_states_output(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		(padded_height, padded_width)				)

  @slow
  def   A__						(				self				)  ->				Union[str, Any]:



        """simple docstring"""






        for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase      = FocalNetModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
              self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)


  def   A__						(				self				)  ->				Any:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

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






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

  @cached_property
  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""				) if is_vision_available() else None


  @slow
  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase      = FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny"""				).to(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = self.default_image_processor

        UpperCamelCase      = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
        UpperCamelCase      = image_processor(images=_SCREAMING_SNAKE_CASE      ,		return_tensors="""pt"""				).to(_SCREAMING_SNAKE_CASE				)

        # forward pass
        with torch.no_grad():
              UpperCamelCase      = model(**_SCREAMING_SNAKE_CASE				)

        # verify the logits
        UpperCamelCase      = torch.Size((1, 1000)				)
        self.assertEqual(outputs.logits.shape      ,		_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]				).to(_SCREAMING_SNAKE_CASE				)
        self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,		_SCREAMING_SNAKE_CASE      ,		atol=1e-4				)				)
        self.assertTrue(outputs.logits.argmax(dim=-1				).item()      ,		281				)






@require_torch
class     a_						(      lowerCamelCase     ,	unittest.TestCase    ):
  lowercase							=				(FocalNetBackbone,) if is_torch_available() else ()
  lowercase							=				FocalNetConfig

  lowercase							=				False

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



        """simple docstring"""






        UpperCamelCase      = FocalNetModelTester(self				)
