



'''simple docstring'''



import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
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 MaskFormerSwinBackbone
							from transformers.models.maskformer import MaskFormerSwinModel
class 						lowerCamelCase_				:







						def __init__(	self :   str					,     lowerCAmelCase__ :   int					,     lowerCAmelCase__ :   Union[str, Any]=13					,     lowerCAmelCase__ :   str=32					,     lowerCAmelCase__ :   Optional[int]=2					,     lowerCAmelCase__ :   Union[str, Any]=3					,     lowerCAmelCase__ :   Tuple=16					,     lowerCAmelCase__ :   Dict=[1, 2, 1]					,     lowerCAmelCase__ :   int=[2, 2, 4]					,     lowerCAmelCase__ :   int=2					,     lowerCAmelCase__ :   Union[str, Any]=2.0					,     lowerCAmelCase__ :   Any=True					,     lowerCAmelCase__ :   Optional[Any]=0.0					,     lowerCAmelCase__ :   Optional[Any]=0.0					,     lowerCAmelCase__ :   Optional[Any]=0.1					,     lowerCAmelCase__ :   Tuple="gelu"					,     lowerCAmelCase__ :   Any=False					,     lowerCAmelCase__ :   List[str]=True					,     lowerCAmelCase__ :   Union[str, Any]=0.02					,     lowerCAmelCase__ :   List[Any]=1e-5					,     lowerCAmelCase__ :   List[str]=True					,     lowerCAmelCase__ :   Dict=None					,     lowerCAmelCase__ :   List[str]=True					,     lowerCAmelCase__ :   List[str]=10					,     lowerCAmelCase__ :   str=8					,     lowerCAmelCase__ :   Any=["stage1", "stage2", "stage3"]					,     lowerCAmelCase__ :   str=[1, 2, 3]					,     ):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      parent
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      batch_size
													SCREAMING_SNAKE_CASE       :   List[str]         =      image_size
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      patch_size
													SCREAMING_SNAKE_CASE       :   Any         =      num_channels
													SCREAMING_SNAKE_CASE       :   str         =      embed_dim
													SCREAMING_SNAKE_CASE       :   Any         =      depths
													SCREAMING_SNAKE_CASE       :   str         =      num_heads
													SCREAMING_SNAKE_CASE       :   Dict         =      window_size
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      mlp_ratio
													SCREAMING_SNAKE_CASE       :   Tuple         =      qkv_bias
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      hidden_dropout_prob
													SCREAMING_SNAKE_CASE       :   int         =      attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE       :   Tuple         =      drop_path_rate
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      hidden_act
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      use_absolute_embeddings
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      patch_norm
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      layer_norm_eps
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      initializer_range
													SCREAMING_SNAKE_CASE       :   Tuple         =      is_training
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      scope
													SCREAMING_SNAKE_CASE       :   Dict         =      use_labels
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      type_sequence_label_size
													SCREAMING_SNAKE_CASE       :   List[str]         =      encoder_stride
													SCREAMING_SNAKE_CASE       :   Tuple         =      out_features
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      out_indices







						def        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Any         =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

													SCREAMING_SNAKE_CASE       :   List[str]         =      None
													if self.use_labels:
																				SCREAMING_SNAKE_CASE       :   str         =      ids_tensor([self.batch_size]					,     self.type_sequence_label_size					)

													SCREAMING_SNAKE_CASE       :   List[str]         =      self.get_config()

													return config, pixel_values, labels







						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													return MaskFormerSwinConfig(
													    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					,     encoder_stride=self.encoder_stride					,     out_features=self.out_features					,     out_indices=self.out_indices					,     )







						def        __lowercase     (	self :   Union[str, Any]					,     lowerCAmelCase__ :   str					,     lowerCAmelCase__ :   Union[str, Any]					,     lowerCAmelCase__ :   List[Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   str         =      MaskFormerSwinModel(config=lowerCAmelCase__					)
													model.to(lowerCAmelCase__					)
													model.eval()
													SCREAMING_SNAKE_CASE       :   List[Any]         =      model(lowerCAmelCase__					)

													SCREAMING_SNAKE_CASE       :   Tuple         =      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
													SCREAMING_SNAKE_CASE       :   Dict         =      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        __lowercase     (	self :   List[Any]					,     lowerCAmelCase__ :   List[Any]					,     lowerCAmelCase__ :   str					,     lowerCAmelCase__ :   Tuple					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   List[Any]         =      MaskFormerSwinBackbone(config=lowerCAmelCase__					)
													model.to(lowerCAmelCase__					)
													model.eval()
													SCREAMING_SNAKE_CASE       :   Dict         =      model(lowerCAmelCase__					)

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

													# verify channels
													self.parent.assertEqual(len(model.channels					)					,     len(config.out_features					)					)
													self.parent.assertListEqual(model.channels					,     [16, 32, 64]					)

													# verify ValueError
													with self.parent.assertRaises(lowerCAmelCase__					):
																				SCREAMING_SNAKE_CASE       :   List[Any]         =      ['''stem''']
																				SCREAMING_SNAKE_CASE       :   List[str]         =      MaskFormerSwinBackbone(config=lowerCAmelCase__					)







						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   List[Any]         =      self.prepare_config_and_inputs()
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Dict         =      config_and_inputs
													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      {'''pixel_values''': pixel_values}
													return config, inputs_dict


@require_torch
class 						lowerCamelCase_				(       snake_case_     ,					snake_case_     ,					unittest.TestCase      ):
						_lowerCAmelCase  : List[str]						  =					(
						    (
						        MaskFormerSwinModel,
						        MaskFormerSwinBackbone,
						    )
						    if is_torch_available()
						    else ()
						)
						_lowerCAmelCase  : int						  =					{'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
						_lowerCAmelCase  : str						  =					False
						_lowerCAmelCase  : Optional[int]						  =					False
						_lowerCAmelCase  : Optional[int]						  =					False
						_lowerCAmelCase  : Union[str, Any]						  =					False
						_lowerCAmelCase  : List[str]						  =					False







						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      MaskFormerSwinModelTester(self					)
													SCREAMING_SNAKE_CASE       :   Dict         =      ConfigTester(self					,     config_class=lowerCAmelCase__					,     embed_dim=37					)







						@require_torch_multi_gpu
						@unittest.skip(
						    reason=(
						        '''`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn\'t work well with'''
						        ''' `nn.DataParallel`'''
						    )					)
						def        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													pass







						def        __lowercase     (	self :   int					):

													"""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        __lowercase     (	self :   Dict					):

													"""simple docstring"""
													return







						def        __lowercase     (	self :   Any					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Tuple         =      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*lowerCAmelCase__					)







						def        __lowercase     (	self :   Optional[int]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   List[str]         =      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_backbone(*lowerCAmelCase__					)







						@unittest.skip('''Swin does not use inputs_embeds'''					)
						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													pass







						@unittest.skip('''Swin does not support feedforward chunking'''					)
						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													pass







						def        __lowercase     (	self :   Any					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Tuple         =      self.model_tester.prepare_config_and_inputs_for_common()

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







						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Tuple         =      self.model_tester.prepare_config_and_inputs_for_common()

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

																				SCREAMING_SNAKE_CASE       :   Optional[int]         =      ['''pixel_values''']
																				self.assertListEqual(arg_names[:1]					,     lowerCAmelCase__					)







						@unittest.skip(reason='''MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'''					)
						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													pass







						@unittest.skip(reason='''MaskFormerSwin is only used as an internal backbone'''					)
						def        __lowercase     (	self :   str					):

													"""simple docstring"""
													pass







						def        __lowercase     (	self :   Optional[Any]					,     lowerCAmelCase__ :   Optional[int]					,     lowerCAmelCase__ :   Tuple					,     lowerCAmelCase__ :   Optional[int]					,     lowerCAmelCase__ :   List[str]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      model_class(lowerCAmelCase__					)
													model.to(lowerCAmelCase__					)
													model.eval()

													with torch.no_grad():
																				SCREAMING_SNAKE_CASE       :   int         =      model(**self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					)					)

													SCREAMING_SNAKE_CASE       :   Optional[Any]         =      outputs.hidden_states

													SCREAMING_SNAKE_CASE       :   Tuple         =      getattr(
													    self.model_tester					,     '''expected_num_hidden_layers'''					,     len(self.model_tester.depths					) + 1					)
													self.assertEqual(len(lowerCAmelCase__					)					,     lowerCAmelCase__					)

													# Swin has a different seq_length
													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      (
													    config.patch_size
													    if isinstance(config.patch_size					,     collections.abc.Iterable					)
													    else (config.patch_size, config.patch_size)
													)

													SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      (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]					,     )







						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   List[Any]         =      self.model_tester.prepare_config_and_inputs_for_common()

													SCREAMING_SNAKE_CASE       :   Optional[int]         =      (
													    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:
																				SCREAMING_SNAKE_CASE       :   int         =      True
																				self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					)

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				SCREAMING_SNAKE_CASE       :   Any         =      True

																				self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					)







						def        __lowercase     (	self :   int					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      self.model_tester.prepare_config_and_inputs_for_common()
													SCREAMING_SNAKE_CASE       :   Tuple         =      3

													SCREAMING_SNAKE_CASE       :   List[Any]         =      (
													    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)
													)
													SCREAMING_SNAKE_CASE       :   str         =      (
													    config.patch_size
													    if isinstance(config.patch_size					,     collections.abc.Iterable					)
													    else (config.patch_size, config.patch_size)
													)

													SCREAMING_SNAKE_CASE       :   str         =      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
													SCREAMING_SNAKE_CASE       :   Optional[int]         =      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

													for model_class in self.all_model_classes:
																				SCREAMING_SNAKE_CASE       :   Any         =      True
																				self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     (padded_height, padded_width)					)

																				# check that output_hidden_states also work using config
																				del inputs_dict["output_hidden_states"]
																				SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      True
																				self.check_hidden_states_output(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     (padded_height, padded_width)					)







						@unittest.skip(reason='''MaskFormerSwin doesn\'t have pretrained checkpoints'''					)
						def        __lowercase     (	self :   List[Any]					):

													"""simple docstring"""
													pass







						@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''					)
						def        __lowercase     (	self :   Union[str, Any]					):

													"""simple docstring"""
													pass







						@unittest.skip(reason='''This will be fixed once MaskFormerSwin is replaced by native Swin'''					)
						def        __lowercase     (	self :   Tuple					):

													"""simple docstring"""
													pass







						def        __lowercase     (	self :   Optional[Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   List[Any]         =      self.model_tester.prepare_config_and_inputs_for_common()

													def set_nan_tensor_to_zero(lowerCAmelCase__ :   int					):
																				SCREAMING_SNAKE_CASE       :   Dict         =      0
																				return t

													def check_equivalence(lowerCAmelCase__ :   List[Any]					,     lowerCAmelCase__ :   Tuple					,     lowerCAmelCase__ :   Optional[Any]					,     lowerCAmelCase__ :   Tuple={}					):
																				with torch.no_grad():
																											SCREAMING_SNAKE_CASE       :   Dict         =      model(**lowerCAmelCase__					,     return_dict=lowerCAmelCase__					,     **lowerCAmelCase__					)
																											SCREAMING_SNAKE_CASE       :   Any         =      model(**lowerCAmelCase__					,     return_dict=lowerCAmelCase__					,     **lowerCAmelCase__					).to_tuple()

																											def recursive_check(lowerCAmelCase__ :   Tuple					,     lowerCAmelCase__ :   Dict					):
																																		if isinstance(lowerCAmelCase__					,     (List, Tuple)					):
																																									for tuple_iterable_value, dict_iterable_value in zip(lowerCAmelCase__					,     lowerCAmelCase__					):
																																																recursive_check(lowerCAmelCase__					,     lowerCAmelCase__					)
																																		elif isinstance(lowerCAmelCase__					,     lowerCAmelCase__					):
																																									for tuple_iterable_value, dict_iterable_value in zip(
																																									    tuple_object.values()					,     dict_object.values()					):
																																																recursive_check(lowerCAmelCase__					,     lowerCAmelCase__					)
																																		elif tuple_object is None:
																																									return
																																		else:
																																									self.assertTrue(
																																									    torch.allclose(
																																									        set_nan_tensor_to_zero(lowerCAmelCase__					)					,     set_nan_tensor_to_zero(lowerCAmelCase__					)					,     atol=1e-5					)					,     msg=(
																																									        '''Tuple and dict output are not equal. Difference:'''
																																									        F""" {torch.max(torch.abs(tuple_object - dict_object					)					)}. Tuple has `nan`:"""
																																									        F""" {torch.isnan(lowerCAmelCase__					).any()} and `inf`: {torch.isinf(lowerCAmelCase__					)}. Dict has"""
																																									        F""" `nan`: {torch.isnan(lowerCAmelCase__					).any()} and `inf`: {torch.isinf(lowerCAmelCase__					)}."""
																																									    )					,     )

																											recursive_check(lowerCAmelCase__					,     lowerCAmelCase__					)

													for model_class in self.all_model_classes:
																				SCREAMING_SNAKE_CASE       :   List[Any]         =      model_class(lowerCAmelCase__					)
																				model.to(lowerCAmelCase__					)
																				model.eval()

																				SCREAMING_SNAKE_CASE       :   Optional[int]         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   str         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					)
																				check_equivalence(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					)

																				SCREAMING_SNAKE_CASE       :   int         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					,     return_labels=lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   str         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					,     return_labels=lowerCAmelCase__					)
																				check_equivalence(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					)

																				SCREAMING_SNAKE_CASE       :   int         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Dict         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					)
																				check_equivalence(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     {'''output_hidden_states''': True}					)

																				SCREAMING_SNAKE_CASE       :   List[str]         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					,     return_labels=lowerCAmelCase__					)
																				SCREAMING_SNAKE_CASE       :   Optional[int]         =      self._prepare_for_class(lowerCAmelCase__					,     lowerCAmelCase__					,     return_labels=lowerCAmelCase__					)
																				check_equivalence(lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     {'''output_hidden_states''': True}					)


@require_torch
class 						lowerCamelCase_				(       unittest.TestCase     ,					snake_case_      ):
						_lowerCAmelCase  : Optional[Any]						  =					(MaskFormerSwinBackbone,) if is_torch_available() else ()
						_lowerCAmelCase  : str						  =					MaskFormerSwinConfig







						def        __lowercase     (	self :   Optional[Any]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       :   List[str]         =      MaskFormerSwinModelTester(self					)







						def        __lowercase     (	self :   Optional[int]					):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   str         =      self.model_tester.prepare_config_and_inputs_for_common()
													SCREAMING_SNAKE_CASE       :   Tuple         =      inputs_dict['''pixel_values'''].shape[0]

													for backbone_class in self.all_model_classes:
																				SCREAMING_SNAKE_CASE       :   int         =      backbone_class(lowerCAmelCase__					)
																				backbone.to(lowerCAmelCase__					)
																				backbone.eval()

																				SCREAMING_SNAKE_CASE       :   Tuple         =      backbone(**lowerCAmelCase__					)

																				# Test default outputs and verify feature maps
																				self.assertIsInstance(outputs.feature_maps					,     lowerCAmelCase__					)
																				self.assertTrue(len(outputs.feature_maps					) == len(backbone.channels					)					)
																				for feature_map, n_channels in zip(outputs.feature_maps					,     backbone.channels					):
																											self.assertTrue(feature_map.shape[:2]					,     (batch_size, n_channels)					)
																				self.assertIsNone(outputs.hidden_states					)
																				self.assertIsNone(outputs.attentions					)

																				# Test output_hidden_states=True
																				SCREAMING_SNAKE_CASE       :   List[str]         =      backbone(**lowerCAmelCase__					,     output_hidden_states=lowerCAmelCase__					)
																				self.assertIsNotNone(outputs.hidden_states					)
																				self.assertTrue(len(outputs.hidden_states					)					,     len(backbone.stage_names					)					)
																				# We skip the stem layer
																				for hidden_states, n_channels in zip(outputs.hidden_states[1:]					,     backbone.channels					):
																											for hidden_state in hidden_states:
																																		# Hidden states are in the format (batch_size, (height * width), n_channels)
																																		SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Optional[int]         =      hidden_state.shape
																																		self.assertTrue((h_batch_size, h_n_channels)					,     (batch_size, n_channels)					)

            # Test output_attentions=True
																				if self.has_attentions:
																											SCREAMING_SNAKE_CASE       :   str         =      backbone(**lowerCAmelCase__					,     output_attentions=lowerCAmelCase__					)
																											self.assertIsNotNone(outputs.attentions					)









'''simple docstring'''



import argparse
from pathlib import Path

import torch

from transformers import OPTConfig, OPTModel
from transformers.utils import logging


logging.set_verbosity_info()
lowerCAmelCase_  :							List[Any]             =    logging.get_logger(__name__)
def        UpperCAmelCase (    A	:					Dict					):
							SCREAMING_SNAKE_CASE       :   List[str]         =      torch.load(A       ,		map_location='''cpu'''					)
							if "model" in sd.keys():
														SCREAMING_SNAKE_CASE       :   List[Any]         =      torch.load(A       ,		map_location='''cpu'''					)['''model''']

							# pop unnecessary weights
							SCREAMING_SNAKE_CASE       :   Optional[int]         =      [
							    '''decoder.version''',
							    '''decoder.output_projection.weight''',
							]
							for key in keys_to_delete:
														if key in sd:
																					sd.pop(A					)

							SCREAMING_SNAKE_CASE       :   int         =      {
							    '''decoder.project_in_dim.weight''': '''decoder.project_in.weight''',
							    '''decoder.project_out_dim.weight''': '''decoder.project_out.weight''',
							    '''decoder.layer_norm.weight''': '''decoder.final_layer_norm.weight''',
							    '''decoder.layer_norm.bias''': '''decoder.final_layer_norm.bias''',
							}
							for old_key, new_key in keys_to_rename.items():
														if old_key in sd:
																					SCREAMING_SNAKE_CASE       :   Optional[int]         =      sd.pop(A					)

							SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      list(sd.keys()					)
							for key in keys:
														if ".qkv_proj." in key:
																					SCREAMING_SNAKE_CASE       :   str         =      sd[key]
																					# We split QKV in separate Q,K,V

																					SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      key.replace('''.qkv_proj.'''       ,		'''.q_proj.'''					)
																					SCREAMING_SNAKE_CASE       :   str         =      key.replace('''.qkv_proj.'''       ,		'''.k_proj.'''					)
																					SCREAMING_SNAKE_CASE       :   Any         =      key.replace('''.qkv_proj.'''       ,		'''.v_proj.'''					)

																					SCREAMING_SNAKE_CASE       :   Tuple         =      value.shape[0]
																					assert depth % 3 == 0
																					# `SequeuceParallelTransformerBlock` has QKV weight is separated in K,V,Q despite the naming:
																					# https://cs.github.com/facebookresearch/metaseq/blob/51871bd73cd04c038f239ea2a26db1d7f6b37927/metaseq/modules/sequence_parallel_transformer_layer.py#L97
																					SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       ,SCREAMING_SNAKE_CASE       :   Tuple         =      torch.split(A       ,		depth // 3       ,		dim=0					)

																					SCREAMING_SNAKE_CASE       :   List[str]         =      q
																					SCREAMING_SNAKE_CASE       :   List[str]         =      k
																					SCREAMING_SNAKE_CASE       :   List[Any]         =      v
																					del sd[key]

							return sd
@torch.no_grad()
def        UpperCAmelCase (    A	:					int       ,		A	:					Union[str, Any]       ,		A	:					Dict=None					):
							SCREAMING_SNAKE_CASE       :   Optional[Any]         =      load_checkpoint(A					)

							if config is not None:
														SCREAMING_SNAKE_CASE       :   Tuple         =      OPTConfig.from_pretrained(A					)
							else:
														SCREAMING_SNAKE_CASE       :   int         =      OPTConfig()

							SCREAMING_SNAKE_CASE       :   Union[str, Any]         =      OPTModel(A					).half().eval()
							model.load_state_dict(A					)

							# Check results
							Path(A					).mkdir(exist_ok=A					)
							model.save_pretrained(A					)


if __name__ == "__main__":
							lowerCAmelCase_  :							List[str]             =    argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '--fairseq_path',
							    type=str,
							    help=(
							        'path to fairseq checkpoint in correct format. You can find all checkpoints in the correct format here:'
							        ' https://huggingface.co/models?other=opt_metasq'
							    ),
							)
							parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
							parser.add_argument('--hf_config', default=None, type=str, help='Define HF config.')
							lowerCAmelCase_  :							str             =    parser.parse_args()
							convert_opt_checkpoint(args.fairseq_path, args.pytorch_dump_folder_path, config=args.hf_config)




