
import inspect
import os
from argparse import ArgumentParser, Namespace
from importlib import import_module

import huggingface_hub
import numpy as np
from packaging import version

from .. import (
    FEATURE_EXTRACTOR_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    PROCESSOR_MAPPING,
    TOKENIZER_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    AutoImageProcessor,
    AutoProcessor,
    AutoTokenizer,
    is_datasets_available,
    is_tf_available,
    is_torch_available,
)
from ..utils import TF2_WEIGHTS_INDEX_NAME, TF2_WEIGHTS_NAME, logging
from . import BaseTransformersCLICommand


if is_tf_available():
				import tensorflow as tf

				tf.config.experimental.enable_tensor_float_aa_execution(False)

if is_torch_available():
				import torch

if is_datasets_available():
				from datasets import load_dataset


lowercase__				:				Dict						=      5e-5  # larger error tolerance than in our internal tests, to avoid flaky user-facing errors




def 						A_			(				snake_case				: Namespace			)   ->     List[str]:



						'''simple docstring'''

						return PTtoTFCommand(
						    args.model_name			,   args.local_dir			,   args.max_error			,   args.new_weights			,   args.no_pr			,   args.push			,   args.extra_commit_description			,   args.override_model_class			,   )






class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_     ):

							"""simple docstring"""






							@staticmethod
							def      A__		(	SCREAMING_SNAKE_CASE_      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      parser.add_parser(
													    '''pt-to-tf'''  ,						help=(
													        '''CLI tool to run convert a transformers model from a PyTorch checkpoint to a TensorFlow checkpoint.'''
													        ''' Can also be used to validate existing weights without opening PRs, with --no-pr.'''
													    )  ,						)
													train_parser.add_argument(
													    '''--model-name'''  ,						type=SCREAMING_SNAKE_CASE_  ,						required=SCREAMING_SNAKE_CASE_  ,						help='''The model name, including owner/organization, as seen on the hub.'''  ,						)
													train_parser.add_argument(
													    '''--local-dir'''  ,						type=SCREAMING_SNAKE_CASE_  ,						default=''''''  ,						help='''Optional local directory of the model repository. Defaults to /tmp/{model_name}'''  ,						)
													train_parser.add_argument(
													    '''--max-error'''  ,						type=SCREAMING_SNAKE_CASE_  ,						default=SCREAMING_SNAKE_CASE_  ,						help=(
													        F"Maximum error tolerance. Defaults to {MAX_ERROR}. This flag should be avoided, use at your own risk."
													    )  ,						)
													train_parser.add_argument(
													    '''--new-weights'''  ,						action='''store_true'''  ,						help='''Optional flag to create new TensorFlow weights, even if they already exist.'''  ,						)
													train_parser.add_argument(
													    '''--no-pr'''  ,						action='''store_true'''  ,						help='''Optional flag to NOT open a PR with converted weights.'''      )
													train_parser.add_argument(
													    '''--push'''  ,						action='''store_true'''  ,						help='''Optional flag to push the weights directly to `main` (requires permissions)'''  ,						)
													train_parser.add_argument(
													    '''--extra-commit-description'''  ,						type=SCREAMING_SNAKE_CASE_  ,						default=''''''  ,						help='''Optional additional commit description to use when opening a PR (e.g. to tag the owner).'''  ,						)
													train_parser.add_argument(
													    '''--override-model-class'''  ,						type=SCREAMING_SNAKE_CASE_  ,						default=SCREAMING_SNAKE_CASE_  ,						help='''If you think you know better than the auto-detector, you can specify the model class here. '''
													    '''Can be either an AutoModel class or a specific model class like BertForSequenceClassification.'''  ,						)
													train_parser.set_defaults(func=SCREAMING_SNAKE_CASE_      )



							@staticmethod
							def      A__		(	SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      set(pt_outputs.keys()      )
													__UpperCamelCase  	=      set(tf_outputs.keys()      )
													if pt_out_attrs != tf_out_attrs:
																			raise ValueError(
																			    F"The model outputs have different attributes, aborting. (Pytorch: {pt_out_attrs}, TensorFlow:"
																			    F" {tf_out_attrs})"      )

													# 2. For each output attribute, computes the difference
													def _find_pt_tf_differences(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=""      ):
																			# If the current attribute is a tensor, it is a leaf and we make the comparison. Otherwise, we will dig in
																			# recursivelly, keeping the name of the attribute.
																			if isinstance(SCREAMING_SNAKE_CASE_  ,						torch.Tensor      ):
																									__UpperCamelCase  	=      np.max(np.abs(pt_out.numpy() - tf_out.numpy()      )      )
																									__UpperCamelCase  	=      tensor_difference
																			else:
																									__UpperCamelCase  	=      attr_name
																									for i, pt_item in enumerate(SCREAMING_SNAKE_CASE_      ):
																															# If it is a named attribute, we keep the name. Otherwise, just its index.
																															if isinstance(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      ):
																																					__UpperCamelCase  	=      root_name + pt_item
																																					__UpperCamelCase  	=      tf_out[pt_item]
																																					__UpperCamelCase  	=      pt_out[pt_item]
																															else:
																																					__UpperCamelCase  	=      root_name + F"[{i}]"
																																					__UpperCamelCase  	=      tf_out[i]
																															__UpperCamelCase  	=      _find_pt_tf_differences(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )

																			return differences

													return _find_pt_tf_differences(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						{}      )



							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						*SCREAMING_SNAKE_CASE_  ,						)-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      logging.get_logger('''transformers-cli/pt_to_tf'''      )
													__UpperCamelCase  	=      model_name
													__UpperCamelCase  	=      local_dir if local_dir else os.path.join('''/tmp'''  ,						SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      max_error
													__UpperCamelCase  	=      new_weights
													__UpperCamelCase  	=      no_pr
													__UpperCamelCase  	=      push
													__UpperCamelCase  	=      extra_commit_description
													__UpperCamelCase  	=      override_model_class



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> str:





													'''simple docstring'''






													def _get_audio_input():
																			__UpperCamelCase  	=      load_dataset('''hf-internal-testing/librispeech_asr_dummy'''  ,						'''clean'''  ,						split='''validation'''      )
																			__UpperCamelCase  	=      ds.sort('''id'''      ).select(range(2      )      )[:2]['''audio''']
																			__UpperCamelCase  	=      [x['''array'''] for x in speech_samples]
																			return raw_samples

													__UpperCamelCase  	=      type(pt_model.config      )
													if model_config_class in PROCESSOR_MAPPING:
																			__UpperCamelCase  	=      AutoProcessor.from_pretrained(self._local_dir      )
																			if model_config_class in TOKENIZER_MAPPING and processor.tokenizer.pad_token is None:
																									__UpperCamelCase  	=      processor.tokenizer.eos_token
													elif model_config_class in IMAGE_PROCESSOR_MAPPING:
																			__UpperCamelCase  	=      AutoImageProcessor.from_pretrained(self._local_dir      )
													elif model_config_class in FEATURE_EXTRACTOR_MAPPING:
																			__UpperCamelCase  	=      AutoFeatureExtractor.from_pretrained(self._local_dir      )
													elif model_config_class in TOKENIZER_MAPPING:
																			__UpperCamelCase  	=      AutoTokenizer.from_pretrained(self._local_dir      )
																			if processor.pad_token is None:
																									__UpperCamelCase  	=      processor.eos_token
													else:
																			raise ValueError(F"Unknown data processing type (model config type: {model_config_class})"      )

													__UpperCamelCase  	=      set(inspect.signature(pt_model.forward      ).parameters.keys()      )
													__UpperCamelCase  	=      {}
													if "input_ids" in model_forward_signature:
																			processor_inputs.update(
																			    {
																			        '''text''': ['''Hi there!''', '''I am a batch with more than one row and different input lengths.'''],
																			        '''padding''': True,
																			        '''truncation''': True,
																			    }      )
													if "pixel_values" in model_forward_signature:
																			__UpperCamelCase  	=      load_dataset('''cifar10'''  ,						'''plain_text'''  ,						split='''test'''      )[:2]['''img''']
																			processor_inputs.update({'''images''': sample_images}      )
													if "input_features" in model_forward_signature:
																			__UpperCamelCase  	=      inspect.signature(processor.feature_extractor      ).parameters
																			# Pad to the largest input length by default but take feature extractor default
																			# padding value if it exists e.g. "max_length" and is not False or None
																			if "padding" in feature_extractor_signature:
																									__UpperCamelCase  	=      feature_extractor_signature['''padding'''].default
																									if default_strategy is not False and default_strategy is not None:
																															__UpperCamelCase  	=      default_strategy
																									else:
																															__UpperCamelCase  	=      True
																			else:
																									__UpperCamelCase  	=      True
																			processor_inputs.update({'''audio''': _get_audio_input(), '''padding''': padding_strategy}      )
													if "input_values" in model_forward_signature:  # Wav2Vec2 audio input
																			processor_inputs.update({'''audio''': _get_audio_input(), '''padding''': True}      )
													__UpperCamelCase  	=      processor(**SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      )
													__UpperCamelCase  	=      processor(**SCREAMING_SNAKE_CASE_  ,						return_tensors='''tf'''      )

													# Extra input requirements, in addition to the input modality
													if (
													    config.is_encoder_decoder
													    or (hasattr(SCREAMING_SNAKE_CASE_  ,						'''encoder'''      ) and hasattr(SCREAMING_SNAKE_CASE_  ,						'''decoder'''      ))
													    or "decoder_input_ids" in tf_dummy_inputs
													):
																			__UpperCamelCase  	=      np.asarray([[1], [1]]  ,						dtype=SCREAMING_SNAKE_CASE_      ) * (pt_model.config.decoder_start_token_id or 0)
																			pt_input.update({'''decoder_input_ids''': torch.tensor(SCREAMING_SNAKE_CASE_      )}      )
																			tf_input.update({'''decoder_input_ids''': tf.convert_to_tensor(SCREAMING_SNAKE_CASE_      )}      )

													return pt_input, tf_input



							def      A__		(	self      )-> int:





													'''simple docstring'''






													if version.parse(huggingface_hub.__version__      ) < version.parse('''0.9.0'''      ):
																			raise ImportError(
																			    '''The huggingface_hub version must be >= 0.9.0 to use this command. Please update your huggingface_hub'''
																			    ''' installation.'''      )
													else:
																			from huggingface_hub import Repository, create_commit
																			from huggingface_hub._commit_api import CommitOperationAdd

													# Fetch remote data
													__UpperCamelCase  	=      Repository(local_dir=self._local_dir  ,						clone_from=self._model_name      )

													# Load config and get the appropriate architecture -- the latter is needed to convert the head's weights
													__UpperCamelCase  	=      AutoConfig.from_pretrained(self._local_dir      )
													__UpperCamelCase  	=      config.architectures
													if self._override_model_class is not None:
																			if self._override_model_class.startswith('''TF'''      ):
																									__UpperCamelCase  	=      [self._override_model_class[2:]]
																			else:
																									__UpperCamelCase  	=      [self._override_model_class]
																			try:
																									__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						architectures[0]      )
																			except AttributeError:
																									raise ValueError(F"Model class {self._override_model_class} not found in transformers."      )
																			try:
																									__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						'''TF''' + architectures[0]      )
																			except AttributeError:
																									raise ValueError(F"TF model class TF{self._override_model_class} not found in transformers."      )
													elif architectures is None:  # No architecture defined -- use auto classes
																			__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						'''AutoModel'''      )
																			__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						'''TFAutoModel'''      )
																			self._logger.warning('''No detected architecture, using AutoModel/TFAutoModel'''      )
													else:  # Architecture defined -- use it
																			if len(SCREAMING_SNAKE_CASE_      ) > 1:
																									raise ValueError(F"More than one architecture was found, aborting. (architectures = {architectures})"      )
																			self._logger.warning(F"Detected architecture: {architectures[0]}"      )
																			__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						architectures[0]      )
																			try:
																									__UpperCamelCase  	=      getattr(import_module('''transformers'''      )  ,						'''TF''' + architectures[0]      )
																			except AttributeError:
																									raise AttributeError(F"The TensorFlow equivalent of {architectures[0]} doesn't exist in transformers."      )

        # Check the TF dummy inputs to see what keys we need in the forward pass
													__UpperCamelCase  	=      tf_class.from_config(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      tf_from_pt_model.dummy_inputs

													del tf_from_pt_model  # Try to keep only one model in memory at a time

													# Load the model and get some basic inputs
													__UpperCamelCase  	=      pt_class.from_pretrained(self._local_dir      )
													pt_model.eval()

													__UpperCamelCase	,				__UpperCamelCase  	=      self.get_inputs(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )

													with torch.no_grad():
																			__UpperCamelCase  	=      pt_model(**SCREAMING_SNAKE_CASE_  ,						output_hidden_states=SCREAMING_SNAKE_CASE_      )
													del pt_model  # will no longer be used, and may have a large memory footprint

													__UpperCamelCase  	=      tf_class.from_pretrained(self._local_dir  ,						from_pt=SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      tf_from_pt_model(**SCREAMING_SNAKE_CASE_  ,						output_hidden_states=SCREAMING_SNAKE_CASE_  ,						training=SCREAMING_SNAKE_CASE_      )

													# Confirms that cross loading PT weights into TF worked.
													__UpperCamelCase  	=      self.find_pt_tf_differences(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      {k: v for k, v in crossload_differences.items() if '''hidden''' not in k}
													__UpperCamelCase  	=      {k: v for k, v in crossload_differences.items() if '''hidden''' in k}
													if len(SCREAMING_SNAKE_CASE_      ) == 0 and architectures is not None:
																			raise ValueError(
																			    F"Something went wrong -- the config file has architectures ({architectures}), but no model head"
																			    ''' output was found. All outputs start with \'hidden\''''      )
													__UpperCamelCase  	=      max(output_differences.values()      ) if output_differences else 0.0
													__UpperCamelCase  	=      max(hidden_differences.values()      )
													if max_crossload_output_diff > self._max_error or max_crossload_hidden_diff > self._max_error:
																			raise ValueError(
																			    '''The cross-loaded TensorFlow model has different outputs, something went wrong!\n'''
																			    + F"\nList of maximum output differences above the threshold ({self._max_error}):\n"
																			    + '''\n'''.join([F"{k}: {v:.3e}" for k, v in output_differences.items() if v > self._max_error]      )
																			    + F"\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"
																			    + '''\n'''.join([F"{k}: {v:.3e}" for k, v in hidden_differences.items() if v > self._max_error]      )      )

													# Save the weights in a TF format (if needed) and confirms that the results are still good
													__UpperCamelCase  	=      os.path.join(self._local_dir  ,						SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      os.path.join(self._local_dir  ,						SCREAMING_SNAKE_CASE_      )
													if (not os.path.exists(SCREAMING_SNAKE_CASE_      ) and not os.path.exists(SCREAMING_SNAKE_CASE_      )) or self._new_weights:
																			tf_from_pt_model.save_pretrained(self._local_dir      )
													del tf_from_pt_model  # will no longer be used, and may have a large memory footprint

													__UpperCamelCase  	=      tf_class.from_pretrained(self._local_dir      )
													__UpperCamelCase  	=      tf_model(**SCREAMING_SNAKE_CASE_  ,						output_hidden_states=SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      self.find_pt_tf_differences(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      {k: v for k, v in conversion_differences.items() if '''hidden''' not in k}
													__UpperCamelCase  	=      {k: v for k, v in conversion_differences.items() if '''hidden''' in k}
													if len(SCREAMING_SNAKE_CASE_      ) == 0 and architectures is not None:
																			raise ValueError(
																			    F"Something went wrong -- the config file has architectures ({architectures}), but no model head"
																			    ''' output was found. All outputs start with \'hidden\''''      )
													__UpperCamelCase  	=      max(output_differences.values()      ) if output_differences else 0.0
													__UpperCamelCase  	=      max(hidden_differences.values()      )
													if max_conversion_output_diff > self._max_error or max_conversion_hidden_diff > self._max_error:
																			raise ValueError(
																			    '''The converted TensorFlow model has different outputs, something went wrong!\n'''
																			    + F"\nList of maximum output differences above the threshold ({self._max_error}):\n"
																			    + '''\n'''.join([F"{k}: {v:.3e}" for k, v in output_differences.items() if v > self._max_error]      )
																			    + F"\n\nList of maximum hidden layer differences above the threshold ({self._max_error}):\n"
																			    + '''\n'''.join([F"{k}: {v:.3e}" for k, v in hidden_differences.items() if v > self._max_error]      )      )

													__UpperCamelCase  	=      '''Update TF weights''' if self._new_weights else '''Add TF weights'''
													if self._push:
																			repo.git_add(auto_lfs_track=SCREAMING_SNAKE_CASE_      )
																			repo.git_commit(SCREAMING_SNAKE_CASE_      )
																			repo.git_push(blocking=SCREAMING_SNAKE_CASE_      )  # this prints a progress bar with the upload
																			self._logger.warning(F"TF weights pushed into {self._model_name}"      )
													elif not self._no_pr:
																			self._logger.warning('''Uploading the weights into a new PR...'''      )
																			__UpperCamelCase  	=      (
																			    '''Model converted by the [`transformers`\' `pt_to_tf`'''
																			    ''' CLI](https://github.com/huggingface/transformers/blob/main/src/transformers/commands/pt_to_tf.py). '''
																			    '''All converted model outputs and hidden layers were validated against its PyTorch counterpart.\n\n'''
																			    F"Maximum crossload output difference={max_crossload_output_diff:.3e}; "
																			    F"Maximum crossload hidden layer difference={max_crossload_hidden_diff:.3e};\n"
																			    F"Maximum conversion output difference={max_conversion_output_diff:.3e}; "
																			    F"Maximum conversion hidden layer difference={max_conversion_hidden_diff:.3e};\n"
																			)
																			if self._max_error > MAX_ERROR:
																									commit_descrition += (
																									    F"\n\nCAUTION: The maximum admissible error was manually increased to {self._max_error}!"
																									)
																			if self._extra_commit_description:
																									commit_descrition += "\n\n" + self._extra_commit_description

																			# sharded model -> adds all related files (index and .h5 shards)
																			if os.path.exists(SCREAMING_SNAKE_CASE_      ):
																									__UpperCamelCase  	=      [
																									    CommitOperationAdd(path_in_repo=SCREAMING_SNAKE_CASE_  ,						path_or_fileobj=SCREAMING_SNAKE_CASE_      )
																									]
																									for shard_path in tf.io.gfile.glob(self._local_dir + '''/tf_model-*.h5'''      ):
																															operations += [
																															    CommitOperationAdd(path_in_repo=os.path.basename(SCREAMING_SNAKE_CASE_      )  ,						path_or_fileobj=SCREAMING_SNAKE_CASE_      )
																															]
																			else:
																									__UpperCamelCase  	=      [CommitOperationAdd(path_in_repo=SCREAMING_SNAKE_CASE_  ,						path_or_fileobj=SCREAMING_SNAKE_CASE_      )]

																			__UpperCamelCase  	=      create_commit(
																			    repo_id=self._model_name  ,						operations=SCREAMING_SNAKE_CASE_  ,						commit_message=SCREAMING_SNAKE_CASE_  ,						commit_description=SCREAMING_SNAKE_CASE_  ,						repo_type='''model'''  ,						create_pr=SCREAMING_SNAKE_CASE_  ,						).pr_url
																			self._logger.warning(F"PR open in {hub_pr_url}"      )











'''simple docstring'''


import inspect
import unittest

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

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 SwinaSRForImageSuperResolution, SwinaSRModel
    from transformers.models.swinasr.modeling_swinasr import SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
    from PIL import Image

    from transformers import SwinaSRImageProcessor


class 		UpperCamelCase__     :
      '''simple docstring'''






      def __init__(     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE=13     , SCREAMING_SNAKE_CASE=32     , SCREAMING_SNAKE_CASE=1     , SCREAMING_SNAKE_CASE=3     , SCREAMING_SNAKE_CASE=16     , 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=False     , SCREAMING_SNAKE_CASE=2     , )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  parent
        __lowerCAmelCase		:    List[str]			     =  batch_size
        __lowerCAmelCase		:    int			     =  image_size
        __lowerCAmelCase		:    List[Any]			     =  patch_size
        __lowerCAmelCase		:    List[Any]			     =  num_channels
        __lowerCAmelCase		:    Any			     =  embed_dim
        __lowerCAmelCase		:    List[str]			     =  depths
        __lowerCAmelCase		:    List[str]			     =  num_heads
        __lowerCAmelCase		:    Any			     =  window_size
        __lowerCAmelCase		:    Any			     =  mlp_ratio
        __lowerCAmelCase		:    Tuple			     =  qkv_bias
        __lowerCAmelCase		:    Optional[Any]			     =  hidden_dropout_prob
        __lowerCAmelCase		:    str			     =  attention_probs_dropout_prob
        __lowerCAmelCase		:    Optional[Any]			     =  drop_path_rate
        __lowerCAmelCase		:    Dict			     =  hidden_act
        __lowerCAmelCase		:    Dict			     =  use_absolute_embeddings
        __lowerCAmelCase		:    List[str]			     =  patch_norm
        __lowerCAmelCase		:    Dict			     =  layer_norm_eps
        __lowerCAmelCase		:    str			     =  initializer_range
        __lowerCAmelCase		:    int			     =  is_training
        __lowerCAmelCase		:    Optional[int]			     =  scope
        __lowerCAmelCase		:    str			     =  use_labels
        __lowerCAmelCase		:    int			     =  upscale

        # here we set some attributes to make tests pass
        __lowerCAmelCase		:    Any			     =  len(SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  embed_dim
        __lowerCAmelCase		:    Union[str, Any]			     =  (image_size // patch_size) ** 2




      def 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Union[str, Any]			     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

        __lowerCAmelCase		:    Union[str, Any]			     =  None
        if self.use_labels:
          __lowerCAmelCase		:    int			     =  ids_tensor([self.batch_size]     , self.type_sequence_label_size )

        __lowerCAmelCase		:    List[Any]			     =  self.get_config()

        return config, pixel_values, labels




      def 	snake_case  (     self )				->  Any:
        return SwinaSRConfig(
            image_size=self.image_size     , patch_size=self.patch_size     , num_channels=self.num_channels     , embed_dim=self.embed_dim     , 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     , upscale=self.upscale     , )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Optional[Any]:
        __lowerCAmelCase		:    Dict			     =  SwinaSRModel(config=SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Dict			     =  model(SCREAMING_SNAKE_CASE )

        self.parent.assertEqual(
            result.last_hidden_state.shape     , (self.batch_size, self.embed_dim, self.image_size, self.image_size) )




      def 	snake_case  (     self     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE )				->  Dict:
        __lowerCAmelCase		:    Any			     =  SwinaSRForImageSuperResolution(SCREAMING_SNAKE_CASE )
        model.to(SCREAMING_SNAKE_CASE )
        model.eval()
        __lowerCAmelCase		:    Tuple			     =  model(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    Dict			     =  self.image_size * self.upscale
        self.parent.assertEqual(
            result.reconstruction.shape     , (self.batch_size, self.num_channels, expected_image_size, expected_image_size) )







      def 	snake_case  (     self )				->  Any:
        __lowerCAmelCase		:    List[Any]			     =  self.prepare_config_and_inputs()
        __lowerCAmelCase     ,					__lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  config_and_inputs
        __lowerCAmelCase		:    str			     =  {'pixel_values': pixel_values}
        return config, inputs_dict



@require_torch
class 		UpperCamelCase__     (       a	,	a	,	unittest.TestCase							):
      '''simple docstring'''






      _snake_case           =				(SwinaSRModel, SwinaSRForImageSuperResolution) if is_torch_available() else ()
      _snake_case           =				{'''feature-extraction''': SwinaSRModel} if is_torch_available() else {}

      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False
      _snake_case           =				False




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRModelTester(self )
        __lowerCAmelCase		:    List[str]			     =  ConfigTester(self     , config_class=SCREAMING_SNAKE_CASE     , embed_dim=37 )




      def 	snake_case  (     self )				->  Optional[int]:
        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 	snake_case  (     self )				->  Tuple:
        __lowerCAmelCase		:    Optional[int]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[Any]:
        __lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_super_resolution(*SCREAMING_SNAKE_CASE )




      @unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.' )
      def 	snake_case  (     self )				->  Any:
        pass




      @unittest.skip(reason='Swin2SR does not use inputs_embeds' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  int:
        pass




      @unittest.skip(reason='Swin2SR does not support training yet' )
      def 	snake_case  (     self )				->  List[str]:
        pass




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Any			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    List[str]			     =  model_class(SCREAMING_SNAKE_CASE )
          self.assertIsInstance(model.get_input_embeddings()     , (nn.Module) )
          __lowerCAmelCase		:    Union[str, Any]			     =  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE     , nn.Linear ) )




      def 	snake_case  (     self )				->  int:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    str			     =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Optional[Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          __lowerCAmelCase		:    List[str]			     =  inspect.signature(model.forward )
          # signature.parameters is an OrderedDict => so arg_names order is deterministic
          __lowerCAmelCase		:    Optional[int]			     =  [*signature.parameters.keys()]

          __lowerCAmelCase		:    Dict			     =  ['pixel_values']
          self.assertListEqual(arg_names[:1]     , SCREAMING_SNAKE_CASE )




      @slow
      def 	snake_case  (     self )				->  List[Any]:
        for model_name in SWIN2SR_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __lowerCAmelCase		:    Any			     =  SwinaSRModel.from_pretrained(SCREAMING_SNAKE_CASE )
          self.assertIsNotNone(SCREAMING_SNAKE_CASE )




      def 	snake_case  (     self )				->  Optional[int]:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Union[str, Any]			     =  self.model_tester.prepare_config_and_inputs_for_common()

        __lowerCAmelCase		:    List[Any]			     =  _config_zero_init(SCREAMING_SNAKE_CASE )
        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Any			     =  model_class(config=SCREAMING_SNAKE_CASE )
          for name, param in model.named_parameters():
            if "logit_scale" in name:
              continue
            if 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"""     , )







      def 	snake_case  (     self )				->  Dict:
        __lowerCAmelCase     ,					__lowerCAmelCase		:    Dict			     =  self.model_tester.prepare_config_and_inputs_for_common()
        __lowerCAmelCase		:    Dict			     =  True

        for model_class in self.all_model_classes:
          __lowerCAmelCase		:    Tuple			     =  True
          __lowerCAmelCase		:    int			     =  False
          __lowerCAmelCase		:    Dict			     =  True
          __lowerCAmelCase		:    Optional[int]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Any			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Dict			     =  outputs.attentions
          __lowerCAmelCase		:    Optional[Any]			     =  len(self.model_tester.depths )
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          # check that output_attentions also work using config
          del inputs_dict["output_attentions"]
          __lowerCAmelCase		:    str			     =  True
          __lowerCAmelCase		:    Any			     =  config.window_size**2
          __lowerCAmelCase		:    int			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    Optional[int]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )
          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions
          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )
          __lowerCAmelCase		:    Dict			     =  len(SCREAMING_SNAKE_CASE )

          # Check attention is always last and order is fine
          __lowerCAmelCase		:    Optional[int]			     =  True
          __lowerCAmelCase		:    List[Any]			     =  True
          __lowerCAmelCase		:    Union[str, Any]			     =  model_class(SCREAMING_SNAKE_CASE )
          model.to(SCREAMING_SNAKE_CASE )
          model.eval()
          with torch.no_grad():
            __lowerCAmelCase		:    List[str]			     =  model(**self._prepare_for_class(SCREAMING_SNAKE_CASE     , SCREAMING_SNAKE_CASE ) )

          self.assertEqual(out_len + 1     , len(SCREAMING_SNAKE_CASE ) )

          __lowerCAmelCase		:    Optional[Any]			     =  outputs.attentions

          self.assertEqual(len(SCREAMING_SNAKE_CASE )     , SCREAMING_SNAKE_CASE )

          self.assertListEqual(
              list(self_attentions[0].shape[-3:] )     , [self.model_tester.num_heads[0], window_size_squared, window_size_squared]     , )



@require_vision
@require_torch
@slow
class 		UpperCamelCase__     (       unittest.TestCase							):
      '''simple docstring'''






      def 	snake_case  (     self )				->  str:
        __lowerCAmelCase		:    int			     =  SwinaSRImageProcessor()
        __lowerCAmelCase		:    Optional[Any]			     =  SwinaSRForImageSuperResolution.from_pretrained('caidas/swin2SR-classical-sr-x2-64' ).to(SCREAMING_SNAKE_CASE )

        __lowerCAmelCase		:    int			     =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
        __lowerCAmelCase		:    Union[str, Any]			     =  processor(images=SCREAMING_SNAKE_CASE     , return_tensors='pt' ).to(SCREAMING_SNAKE_CASE )

        # forward pass
        with torch.no_grad():
          __lowerCAmelCase		:    List[Any]			     =  model(**SCREAMING_SNAKE_CASE )

        # verify the logits
        __lowerCAmelCase		:    Dict			     =  torch.Size([1, 3, 9_76, 12_96] )
        self.assertEqual(outputs.reconstruction.shape     , SCREAMING_SNAKE_CASE )
        __lowerCAmelCase		:    Optional[int]			     =  torch.tensor(
            [[0.5_4_5_8, 0.5_5_4_6, 0.5_6_3_8], [0.5_5_2_6, 0.5_5_6_5, 0.5_6_5_1], [0.5_3_9_6, 0.5_4_2_6, 0.5_6_2_1]] ).to(SCREAMING_SNAKE_CASE )
        self.assertTrue(torch.allclose(outputs.reconstruction[0, 0, :3, :3]     , SCREAMING_SNAKE_CASE     , atol=1e-4 ) )





