
import io
import json
import unittest

from parameterized import parameterized

from transformers import FSMTForConditionalGeneration, FSMTTokenizer
from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device
from utils import calculate_bleu


__lowerCamelCase							=       get_tests_dir() + """/test_data/fsmt/fsmt_val_data.json"""
with io.open(filename, """r""", encoding="""utf-8""") as f:
   __lowerCamelCase							=       json.load(f)






@require_torch
class   UpperCAmelCase		(						unittest.TestCase ):



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


          '''simple docstring'''


          return FSMTTokenizer.from_pretrained(snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int]    ,						snake_case__		:					Tuple )		->	int:


          '''simple docstring'''


          snake_case       :   str							=      FSMTForConditionalGeneration.from_pretrained(snake_case__ ).to(snake_case__ )
          if torch_device == "cuda":
                 model.half()
          return model



   @parameterized.expand(
       [
           ["en-ru", 26.0],
           ["ru-en", 22.0],
           ["en-de", 22.0],
           ["de-en", 29.0],
       ] )
   @slow
   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict    ,						snake_case__		:					Optional[int]    ,						snake_case__		:					Tuple )		->	Dict:


          '''simple docstring'''


          snake_case       :   List[str]							=      f"""facebook/wmt19-{pair}"""
          snake_case       :   str							=      self.get_tokenizer(snake_case__ )
          snake_case       :   int							=      self.get_model(snake_case__ )

          snake_case       :   Any							=      bleu_data[pair]["src"]
          snake_case       :   Tuple							=      bleu_data[pair]["tgt"]

          snake_case       :   int							=      tokenizer(snake_case__    ,						return_tensors="pt"    ,						truncation=snake_case__    ,						padding="longest" ).to(snake_case__ )
          snake_case       :   Optional[int]							=      model.generate(
              input_ids=batch.input_ids    ,						num_beams=8    ,						)
          snake_case       :   Optional[int]							=      tokenizer.batch_decode(
              snake_case__    ,						skip_special_tokens=snake_case__    ,						clean_up_tokenization_spaces=snake_case__ )
          snake_case       :   Dict							=      calculate_bleu(snake_case__    ,						snake_case__ )
          print(snake_case__ )
          self.assertGreaterEqual(scores["bleu"]    ,						snake_case__ )







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   UpperCAmelCase		:



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


          '''simple docstring'''


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



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


          snake_case       :   Optional[Any]							=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

          snake_case       :   int							=      None
          if self.use_labels:
                 snake_case       :   Tuple							=      ids_tensor([self.batch_size]    ,						self.type_sequence_label_size )

          snake_case       :   Dict							=      self.get_config()

          return config, pixel_values, labels



   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	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 				_SCREAMING_SNAKE_CASE   (self		:					Tuple    ,						snake_case__		:					List[Any]    ,						snake_case__		:					List[str]    ,						snake_case__		:					Tuple )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModel(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(snake_case__ )

          snake_case       :   Dict							=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
          snake_case       :   int							=      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 				_SCREAMING_SNAKE_CASE   (self		:					List[str]    ,						snake_case__		:					Union[str, Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Union[str, Any] )		->	str:


          '''simple docstring'''


          snake_case       :   Optional[int]							=      MaskFormerSwinBackbone(config=snake_case__ )
          model.to(snake_case__ )
          model.eval()
          snake_case       :   List[Any]							=      model(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 )    ,						[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(snake_case__ ):
                 snake_case       :   Tuple							=      ["stem"]
                 snake_case       :   List[Any]							=      MaskFormerSwinBackbone(config=snake_case__ )



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


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      self.prepare_config_and_inputs()
          snake_case				,					snake_case				,					snake_case       :   List[Any]							=      config_and_inputs
          snake_case       :   int							=      {"pixel_values": pixel_values}
          return config, inputs_dict






@require_torch
class   UpperCAmelCase		(						A_       ,A_       ,unittest.TestCase ):
   A__					:		List[str]						     =     (
       (
           MaskFormerSwinModel,
           MaskFormerSwinBackbone,
       )
       if is_torch_available()
       else ()
   )
   A__					:		str						     =     {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
   A__					:		Optional[Any]						     =     False
   A__					:		List[Any]						     =     False
   A__					:		List[str]						     =     False
   A__					:		List[str]						     =     False
   A__					:		Union[str, Any]						     =     False



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	List[str]:


          '''simple docstring'''


          snake_case       :   str							=      MaskFormerSwinModelTester(self )
          snake_case       :   Optional[int]							=      ConfigTester(self    ,						config_class=snake_case__    ,						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 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	Optional[Any]:


          '''simple docstring'''


          pass



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


          '''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 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	List[Any]:


          '''simple docstring'''


          return



   def 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	str:


          '''simple docstring'''


          snake_case       :   str							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Dict:


          '''simple docstring'''


          snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_backbone(*snake_case__ )



   @unittest.skip("Swin does not use inputs_embeds" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          pass



   @unittest.skip("Swin does not support feedforward chunking" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[str] )		->	Dict:


          '''simple docstring'''


          pass



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


          '''simple docstring'''


          snake_case				,					snake_case       :   Any							=      self.model_tester.prepare_config_and_inputs_for_common()

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



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any] )		->	Dict:


          '''simple docstring'''


          snake_case				,					snake_case       :   str							=      self.model_tester.prepare_config_and_inputs_for_common()

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

                 snake_case       :   Tuple							=      ["pixel_values"]
                 self.assertListEqual(arg_names[:1]    ,						snake_case__ )



   @unittest.skip(reason="MaskFormerSwin is only used as backbone and doesn't support output_attentions" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					List[Any] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="MaskFormerSwin is only used as an internal backbone" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Tuple )		->	Any:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[Any]    ,						snake_case__		:					List[Any]    ,						snake_case__		:					str    ,						snake_case__		:					List[Any]    ,						snake_case__		:					Tuple )		->	Optional[int]:


          '''simple docstring'''


          snake_case       :   Tuple							=      model_class(snake_case__ )
          model.to(snake_case__ )
          model.eval()

          with torch.no_grad():
                 snake_case       :   Any							=      model(**self._prepare_for_class(snake_case__    ,						snake_case__ ) )

          snake_case       :   int							=      outputs.hidden_states

          snake_case       :   Union[str, Any]							=      getattr(
              self.model_tester    ,						"expected_num_hidden_layers"    ,						len(self.model_tester.depths ) + 1 )
          self.assertEqual(len(snake_case__ )    ,						snake_case__ )

          # Swin has a different seq_length
          snake_case       :   Any							=      (
              config.patch_size
              if isinstance(config.patch_size    ,						collections.abc.Iterable )
              else (config.patch_size, config.patch_size)
          )

          snake_case       :   Tuple							=      (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 				_SCREAMING_SNAKE_CASE   (self		:					Dict )		->	Union[str, Any]:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          snake_case       :   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:
                 snake_case       :   int							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )

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

                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   Union[str, Any]							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Any							=      3

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

          snake_case       :   str							=      image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          snake_case       :   str							=      image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
                 snake_case       :   str							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 snake_case       :   Optional[Any]							=      True
                 self.check_hidden_states_output(snake_case__    ,						snake_case__    ,						snake_case__    ,						(padded_height, padded_width) )



   @unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	str:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	int:


          '''simple docstring'''


          pass



   @unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin" )
   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	str:


          '''simple docstring'''


          pass



   def 				_SCREAMING_SNAKE_CASE   (self		:					Any )		->	Any:


          '''simple docstring'''


          snake_case				,					snake_case       :   List[Any]							=      self.model_tester.prepare_config_and_inputs_for_common()

          def set_nan_tensor_to_zero(snake_case__		:					Union[str, Any] ):
                 snake_case       :   Any							=      0
                 return t

          def check_equivalence(snake_case__		:					Union[str, Any]    ,						snake_case__		:					int    ,						snake_case__		:					List[str]    ,						snake_case__		:					Optional[int]={} ):
                 with torch.no_grad():
                        snake_case       :   Optional[Any]							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ )
                        snake_case       :   Tuple							=      model(**snake_case__    ,						return_dict=snake_case__    ,						**snake_case__ ).to_tuple()

                        def recursive_check(snake_case__		:					List[str]    ,						snake_case__		:					Optional[Any] ):
                               if isinstance(snake_case__    ,						(List, Tuple) ):
                                      for tuple_iterable_value, dict_iterable_value in zip(snake_case__    ,						snake_case__ ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif isinstance(snake_case__    ,						snake_case__ ):
                                      for tuple_iterable_value, dict_iterable_value in zip(
                                          tuple_object.values()    ,						dict_object.values() ):
                                             recursive_check(snake_case__    ,						snake_case__ )
                               elif tuple_object is None:
                                      return
                               else:
                                      self.assertTrue(
                                          torch.allclose(
                                              set_nan_tensor_to_zero(snake_case__ )    ,						set_nan_tensor_to_zero(snake_case__ )    ,						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(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}. Dict has"""
                                              f""" `nan`: {torch.isnan(snake_case__ ).any()} and `inf`: {torch.isinf(snake_case__ )}."""
                                          )    ,						)

                        recursive_check(snake_case__    ,						snake_case__ )

          for model_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      model_class(snake_case__ )
                 model.to(snake_case__ )
                 model.eval()

                 snake_case       :   Union[str, Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Tuple							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   Optional[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__ )

                 snake_case       :   Dict							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 snake_case       :   List[Any]							=      self._prepare_for_class(snake_case__    ,						snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )

                 snake_case       :   Any							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 snake_case       :   List[str]							=      self._prepare_for_class(snake_case__    ,						snake_case__    ,						return_labels=snake_case__ )
                 check_equivalence(snake_case__    ,						snake_case__    ,						snake_case__    ,						{"output_hidden_states": True} )






@require_torch
class   UpperCAmelCase		(						unittest.TestCase       ,A_ ):
   A__					:		int						     =     (MaskFormerSwinBackbone,) if is_torch_available() else ()
   A__					:		int						     =     MaskFormerSwinConfig



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


          '''simple docstring'''


          snake_case       :   Union[str, Any]							=      MaskFormerSwinModelTester(self )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Optional[Any]:


          '''simple docstring'''


          snake_case				,					snake_case       :   Dict							=      self.model_tester.prepare_config_and_inputs_for_common()
          snake_case       :   Optional[int]							=      inputs_dict["pixel_values"].shape[0]

          for backbone_class in self.all_model_classes:
                 snake_case       :   Optional[int]							=      backbone_class(snake_case__ )
                 backbone.to(snake_case__ )
                 backbone.eval()

                 snake_case       :   Union[str, Any]							=      backbone(**snake_case__ )

                 # Test default outputs and verify feature maps
                 self.assertIsInstance(outputs.feature_maps    ,						snake_case__ )
                 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
                 snake_case       :   Optional[int]							=      backbone(**snake_case__    ,						output_hidden_states=snake_case__ )
                 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)
                               snake_case				,					snake_case				,					snake_case       :   Dict							=      hidden_state.shape
                               self.assertTrue((h_batch_size, h_n_channels)    ,						(batch_size, n_channels) )

            # Test output_attentions=True
                 if self.has_attentions:
                        snake_case       :   Optional[Any]							=      backbone(**snake_case__    ,						output_attentions=snake_case__ )
                        self.assertIsNotNone(outputs.attentions )





