




'''simple docstring'''


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_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


if is_torch_available():
    import torch

    from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin

class       A   :







       def __init__(  self	:  str							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  List[Any]=None							,      lowerCAmelCase_	:  str=None							,      lowerCAmelCase_	:  Optional[Any]=None							,      lowerCAmelCase_	:  Union[str, Any]="resnet50"							,      lowerCAmelCase_	:  Union[str, Any]=3							,      lowerCAmelCase_	:  Any=32							,      lowerCAmelCase_	:  Optional[int]=3							,      lowerCAmelCase_	:  Union[str, Any]=True							,      lowerCAmelCase_	:  Union[str, Any]=True							,      )      ->							Optional[int]:


              """simple docstring"""


              _a     					=    parent
              _a     					=    out_indices if out_indices is not None else [4]
              _a     					=    stage_names
              _a     					=    out_features
              _a     					=    backbone
              _a     					=    batch_size
              _a     					=    image_size
              _a     					=    num_channels
              _a     					=    use_pretrained_backbone
              _a     					=    is_training







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


              """simple docstring"""


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

              return config, pixel_values







       def        __lowerCAmelCase      (  self	:  Tuple )      ->							str:


              """simple docstring"""


              return TimmBackboneConfig(
                  image_size=self.image_size							,      num_channels=self.num_channels							,      out_features=self.out_features							,      out_indices=self.out_indices							,      stage_names=self.stage_names							,      use_pretrained_backbone=self.use_pretrained_backbone							,      backbone=self.backbone							,      )







       def        __lowerCAmelCase      (  self	:  Optional[Any]							,      lowerCAmelCase_	:  str							,      lowerCAmelCase_	:  List[str] )      ->							Optional[Any]:


              """simple docstring"""


              _a     					=    TimmBackbone(config=a_ )
              model.to(a_ )
              model.eval()
              with torch.no_grad():
                     _a     					=    model(a_ )
              self.parent.assertEqual(
                  result.feature_map[-1].shape							,      (self.batch_size, model.channels[-1], 14, 14)							,      )







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


              """simple docstring"""


              _a     					=    self.prepare_config_and_inputs()
              _a     					=    config_and_inputs
              _a     					=    {'''pixel_values''': pixel_values}
              return config, inputs_dict



@require_torch
@require_timm
class       A   (		__snake_case					,__snake_case					,__snake_case					,unittest.TestCase   ):
       lowercase_          =    (TimmBackbone,) if is_torch_available() else ()
       lowercase_          =    {'feature-extraction': TimmBackbone} if is_torch_available() else {}
       lowercase_          =    False
       lowercase_          =    False
       lowercase_          =    False
       lowercase_          =    False







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


              """simple docstring"""


              _a     					=    TimmBackboneModelTester(self )
              _a     					=    ConfigTester(self							,      config_class=a_							,      has_text_modality=a_ )







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


              """simple docstring"""


              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        __lowerCAmelCase      (  self	:  List[str] )      ->							Optional[int]:


              """simple docstring"""


              _a     					=    '''resnet18'''
              _a     					=    '''microsoft/resnet-18'''

              _a     					=    AutoBackbone.from_pretrained(a_							,      use_timm_backbone=a_ )
              _a     					=    AutoBackbone.from_pretrained(a_ )

              self.assertEqual(len(timm_model.out_features )							,      len(transformers_model.out_features ) )
              self.assertEqual(len(timm_model.stage_names )							,      len(transformers_model.stage_names ) )
              self.assertEqual(timm_model.channels							,      transformers_model.channels )
              # Out indices are set to the last layer by default. For timm models, we don't know
              # the number of layers in advance, so we set it to (-1,), whereas for transformers
              # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
              self.assertEqual(timm_model.out_indices							,      (-1,) )
              self.assertEqual(transformers_model.out_indices							,      [len(timm_model.stage_names ) - 1] )

              _a     					=    AutoBackbone.from_pretrained(a_							,      use_timm_backbone=a_							,      out_indices=[1, 2, 3] )
              _a     					=    AutoBackbone.from_pretrained(a_							,      out_indices=[1, 2, 3] )

              self.assertEqual(timm_model.out_indices							,      transformers_model.out_indices )
              self.assertEqual(len(timm_model.out_features )							,      len(transformers_model.out_features ) )
              self.assertEqual(timm_model.channels							,      transformers_model.channels )







       @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking''' )
       def        __lowerCAmelCase      (  self	:  Any )      ->							List[Any]:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute''' )
       def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							List[Any]:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone initialization is managed on the timm side''' )
       def        __lowerCAmelCase      (  self	:  Dict )      ->							Optional[Any]:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
       def        __lowerCAmelCase      (  self	:  Dict )      ->							str:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds''' )
       def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Any:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint''' )
       def        __lowerCAmelCase      (  self	:  Tuple )      ->							Dict:


              """simple docstring"""


              pass







       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
       def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							str:


              """simple docstring"""


              pass







       @unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
       def        __lowerCAmelCase      (  self	:  Tuple )      ->							Union[str, Any]:


              """simple docstring"""


              pass







       @unittest.skip('''model weights aren\'t tied in TimmBackbone.''' )
       def        __lowerCAmelCase      (  self	:  List[Any] )      ->							List[str]:


              """simple docstring"""


              pass







       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
       def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Dict:


              """simple docstring"""


              pass







       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone''' )
       def        __lowerCAmelCase      (  self	:  Tuple )      ->							Any:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.''' )
       def        __lowerCAmelCase      (  self	:  Optional[int] )      ->							Dict:


              """simple docstring"""


              pass







       @unittest.skip('''TimmBackbone doesn\'t support output_attentions.''' )
       def        __lowerCAmelCase      (  self	:  List[Any] )      ->							Optional[Any]:


              """simple docstring"""


              pass







       @unittest.skip('''Safetensors is not supported by timm.''' )
       def        __lowerCAmelCase      (  self	:  Optional[Any] )      ->							List[Any]:


              """simple docstring"""


              pass







       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''' )
       def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


              """simple docstring"""


              pass







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


              """simple docstring"""


              _a     					=    self.model_tester.prepare_config_and_inputs_for_common()

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

                     _a     					=    ['''pixel_values''']
                     self.assertListEqual(arg_names[:1]							,      a_ )







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


              """simple docstring"""


              _a     					=    self.model_tester.prepare_config_and_inputs_for_common()
              _a     					=    True
              _a     					=    self.has_attentions

              # no need to test all models as different heads yield the same functionality
              _a     					=    self.all_model_classes[0]
              _a     					=    model_class(a_ )
              model.to(a_ )

              _a     					=    self._prepare_for_class(a_							,      a_ )
              _a     					=    model(**a_ )
              _a     					=    outputs[0][-1]

              # Encoder-/Decoder-only models
              _a     					=    outputs.hidden_states[0]
              hidden_states.retain_grad()

              if self.has_attentions:
                     _a     					=    outputs.attentions[0]
                     attentions.retain_grad()

              output.flatten()[0].backward(retain_graph=a_ )

              self.assertIsNotNone(hidden_states.grad )

              if self.has_attentions:
                     self.assertIsNotNone(attentions.grad )







       def        __lowerCAmelCase      (  self	:  str )      ->							str:


              """simple docstring"""


              _a     					=    self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     _a     					=    model_class(a_ )
                     model.to(a_ )
                     model.eval()
                     _a     					=    model(**a_ )

                     self.assertEqual(len(result.feature_maps )							,      len(config.out_indices ) )
                     self.assertEqual(len(model.channels )							,      len(config.out_indices ) )

                     # Check output of last stage is taken if out_features=None, out_indices=None
                     _a     					=    copy.deepcopy(a_ )
                     _a     					=    None
                     _a     					=    model_class(a_ )
                     model.to(a_ )
                     model.eval()
                     _a     					=    model(**a_ )

                     self.assertEqual(len(result.feature_maps )							,      1 )
                     self.assertEqual(len(model.channels )							,      1 )

                     # Check backbone can be initialized with fresh weights
                     _a     					=    copy.deepcopy(a_ )
                     _a     					=    False
                     _a     					=    model_class(a_ )
                     model.to(a_ )
                     model.eval()
                     _a     					=    model(**a_ )







'''simple docstring'''


import unittest

from transformers import TrOCRConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers.models.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM

@require_torch
class       A   :







							def __init__(  self	:  Union[str, Any]							,      lowerCAmelCase_	:  List[Any]							,      lowerCAmelCase_	:  Union[str, Any]=99							,      lowerCAmelCase_	:  Optional[int]=13							,      lowerCAmelCase_	:  Tuple=16							,      lowerCAmelCase_	:  Optional[int]=7							,      lowerCAmelCase_	:  Optional[Any]=True							,      lowerCAmelCase_	:  Union[str, Any]=True							,      lowerCAmelCase_	:  Any=True							,      lowerCAmelCase_	:  Union[str, Any]=False							,      lowerCAmelCase_	:  int=True							,      lowerCAmelCase_	:  Tuple=2							,      lowerCAmelCase_	:  Any=32							,      lowerCAmelCase_	:  str=4							,      lowerCAmelCase_	:  Optional[Any]=4							,      lowerCAmelCase_	:  Optional[Any]=30							,      lowerCAmelCase_	:  int=0							,      lowerCAmelCase_	:  Any=1							,      lowerCAmelCase_	:  str=2							,      lowerCAmelCase_	:  Union[str, Any]=None							,      )      ->							Any:


														"""simple docstring"""


														_a     					=    parent
														_a     					=    batch_size
														_a     					=    decoder_seq_length
														# For common tests
														_a     					=    self.decoder_seq_length
														_a     					=    is_training
														_a     					=    use_attention_mask
														_a     					=    use_labels

														_a     					=    vocab_size
														_a     					=    d_model
														_a     					=    d_model
														_a     					=    decoder_layers
														_a     					=    decoder_layers
														_a     					=    decoder_ffn_dim
														_a     					=    decoder_attention_heads
														_a     					=    decoder_attention_heads
														_a     					=    eos_token_id
														_a     					=    bos_token_id
														_a     					=    pad_token_id
														_a     					=    decoder_start_token_id
														_a     					=    use_cache
														_a     					=    max_position_embeddings

														_a     					=    None
														_a     					=    decoder_seq_length
														_a     					=    2
														_a     					=    1







							def        __lowerCAmelCase      (  self	:  str )      ->							str:


														"""simple docstring"""


														_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      self.vocab_size )

														_a     					=    None
														if self.use_attention_mask:
																					_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      vocab_size=2 )

														_a     					=    None
														if self.use_labels:
																					_a     					=    ids_tensor([self.batch_size, self.decoder_seq_length]							,      self.vocab_size )

														_a     					=    TrOCRConfig(
														    vocab_size=self.vocab_size							,      d_model=self.d_model							,      decoder_layers=self.decoder_layers							,      decoder_ffn_dim=self.decoder_ffn_dim							,      decoder_attention_heads=self.decoder_attention_heads							,      eos_token_id=self.eos_token_id							,      bos_token_id=self.bos_token_id							,      use_cache=self.use_cache							,      pad_token_id=self.pad_token_id							,      decoder_start_token_id=self.decoder_start_token_id							,      max_position_embeddings=self.max_position_embeddings							,      )

														return (config, input_ids, attention_mask, lm_labels)







							def        __lowerCAmelCase      (  self	:  List[str]							,      lowerCAmelCase_	:  Any							,      lowerCAmelCase_	:  Dict							,      lowerCAmelCase_	:  Optional[Any]							,      lowerCAmelCase_	:  int							,      )      ->							int:


														"""simple docstring"""


														_a     					=    True
														_a     					=    TrOCRDecoder(config=lowerCAmelCase_ ).to(lowerCAmelCase_ ).eval()
														_a     					=    input_ids[:2]

														input_ids[input_ids == 0] += 1
														# first forward pass
														_a     					=    model(lowerCAmelCase_							,      use_cache=lowerCAmelCase_ )
														_a     					=    model(lowerCAmelCase_ )
														_a     					=    model(lowerCAmelCase_							,      use_cache=lowerCAmelCase_ )

														self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) )
														self.parent.assertTrue(len(lowerCAmelCase_ ) == len(lowerCAmelCase_ ) + 1 )

														_a     					=    outputs['''past_key_values''']

														# create hypothetical next token and extent to next_input_ids
														_a     					=    ids_tensor((2, 1)							,      config.vocab_size - 1 ) + 1

														# append to next input_ids and
														_a     					=    torch.cat([input_ids, next_tokens]							,      dim=-1 )

														_a     					=    model(lowerCAmelCase_ )['''last_hidden_state''']
														_a     					=    model(lowerCAmelCase_							,      past_key_values=lowerCAmelCase_ )['''last_hidden_state''']

														# select random slice
														_a     					=    ids_tensor((1,)							,      output_from_past.shape[-1] ).item()
														_a     					=    output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
														_a     					=    output_from_past[:, 0, random_slice_idx].detach()

														# test that outputs are equal for slice
														assert torch.allclose(lowerCAmelCase_							,      lowerCAmelCase_							,      atol=1e-3 )







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


														"""simple docstring"""


														_a     					=    self.prepare_config_and_inputs()
														_a					,							_a					,							_a					,							_a     					=    config_and_inputs

														_a     					=    {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
														return config, inputs_dict



@require_torch
class       A   (		_a					,_a					,_a					,unittest.TestCase   ):
							lowercase_          =    (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
							lowercase_          =    (TrOCRForCausalLM,) if is_torch_available() else ()
							lowercase_          =    {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
							lowercase_          =    True
							lowercase_          =    False







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


														"""simple docstring"""


														_a     					=    TrOCRStandaloneDecoderModelTester(self							,      is_training=lowerCAmelCase_ )
														_a     					=    ConfigTester(self							,      config_class=lowerCAmelCase_ )







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


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Dict:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														pass







							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


														"""simple docstring"""


														self.config_tester.run_common_tests()







							def        __lowerCAmelCase      (  self	:  Tuple )      ->							Optional[int]:


														"""simple docstring"""


														_a     					=    self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_decoder_model_past(*lowerCAmelCase_ )







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


														"""simple docstring"""


														return







							@unittest.skip('''The model doesn\'t support left padding''' )  # and it's not used enough to be worth fixing :)
							def        __lowerCAmelCase      (  self	:  Union[str, Any] )      ->							Optional[int]:


														"""simple docstring"""


														pass

