




'''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	,    _A	,    _A=9_9	,    _A=1_3	,    _A=1_6	,    _A=7	,    _A=True	,    _A=True	,    _A=True	,    _A=False	,    _A=True	,    _A=2	,    _A=3_2	,    _A=4	,    _A=4	,    _A=3_0	,    _A=0	,    _A=1	,    _A=2	,    _A=None	,    ):




											"""simple docstring"""



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

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

											__lowerCAmelCase            = None
											__lowerCAmelCase            = decoder_seq_length
											__lowerCAmelCase            = 2
											__lowerCAmelCase            = 1






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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

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

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

											__lowerCAmelCase            = 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        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A	,    _A	,    _A	,    ):




											"""simple docstring"""



											__lowerCAmelCase            = True
											__lowerCAmelCase            = TrOCRDecoder(config=_UpperCAmelCase    ).to(_UpperCAmelCase    ).eval()
											__lowerCAmelCase            = input_ids[:2]

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

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

											__lowerCAmelCase            = outputs["past_key_values"]

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

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

											__lowerCAmelCase            = model(_UpperCAmelCase    )["last_hidden_state"]
											__lowerCAmelCase            = model(_UpperCAmelCase	,    past_key_values=_UpperCAmelCase    )["last_hidden_state"]

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

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






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



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

											__lowerCAmelCase            = {"input_ids": input_ids, "attention_mask": attention_mask}
											return config, inputs_dict






@require_torch
class     a__					(      snake_case__				,       snake_case__				,       snake_case__				,       unittest.TestCase   ):
						_a							:					str      =					(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
						_a							:					str      =					(TrOCRForCausalLM,) if is_torch_available() else ()
						_a							:					str      =					{"""text-generation""": TrOCRForCausalLM} if is_torch_available() else {}
						_a							:					Dict      =					True
						_a							:					List[str]      =					False






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = TrOCRStandaloneDecoderModelTester(self	,    is_training=_UpperCAmelCase    )
											__lowerCAmelCase            = ConfigTester(self	,    config_class=_UpperCAmelCase    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											self.config_tester.run_common_tests()






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_decoder_model_past(*_UpperCAmelCase    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											return






						@unittest.skip("The model doesn't support left padding"    )  # and it's not used enough to be worth fixing :)
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											pass










import torch
from transformers import PreTrainedModel, XLMRobertaConfig, XLMRobertaModel
class     a__					(      snake_case__   ):
						_a							:					Optional[Any]      =					"""M-CLIP"""






						def __init__(     self	,    _A=1_0_2_4	,    _A=7_6_8	,    **_A    ):




											"""simple docstring"""



											__lowerCAmelCase            = transformerDimSize
											__lowerCAmelCase            = imageDimSize
											super().__init__(**_A    )






class     a__					(      snake_case__   ):
						_a							:					Tuple      =					MCLIPConfig






						def __init__(     self	,    _A	,    *_A	,    **_A    ):




											"""simple docstring"""



											super().__init__(_A	,    *_A	,    **_A    )
											__lowerCAmelCase            = XLMRobertaModel(_A    )
											__lowerCAmelCase            = torch.nn.Linear(
											    in_features=config.transformerDimensions	,    out_features=config.numDims    )






						def        __SCREAMING_SNAKE_CASE(     self	,    _A	,    _A    ):




											"""simple docstring"""



											__lowerCAmelCase            = self.transformer(input_ids=_A	,    attention_mask=_A    )[0]
											__lowerCAmelCase            = (embs * attention_mask.unsqueeze(2    )).sum(dim=1    ) / attention_mask.sum(dim=1    )[:, None]
											return self.LinearTransformation(_A    ), embs




