






'''simple docstring'''







import unittest

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

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import (
          RemBertConfig,
          RemBertForCausalLM,
          RemBertForMaskedLM,
          RemBertForMultipleChoice,
          RemBertForQuestionAnswering,
          RemBertForSequenceClassification,
          RemBertForTokenClassification,
          RemBertModel,
      )
      from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST






class 					a__    :
     '''simple docstring'''







     def __init__(self    :	List[str]				,				lowercase__    :	List[str]				,				lowercase__    :	str=13				,				lowercase__    :	Dict=7				,				lowercase__    :	str=True				,				lowercase__    :	Tuple=True				,				lowercase__    :	Optional[Any]=True				,				lowercase__    :	Optional[int]=True				,				lowercase__    :	Dict=99				,				lowercase__    :	Tuple=32				,				lowercase__    :	str=18				,				lowercase__    :	Union[str, Any]=43				,				lowercase__    :	int=5				,				lowercase__    :	Optional[Any]=4				,				lowercase__    :	int=37				,				lowercase__    :	Tuple="gelu"				,				lowercase__    :	str=0.1				,				lowercase__    :	Dict=0.1				,				lowercase__    :	Optional[int]=512				,				lowercase__    :	Tuple=16				,				lowercase__    :	Any=2				,				lowercase__    :	str=0.02				,				lowercase__    :	Dict=3				,				lowercase__    :	Any=4				,				lowercase__    :	Optional[int]=None				,				)  ->       List[Any]:
           __A		   =      parent
           __A		   =      batch_size
           __A		   =      seq_length
           __A		   =      is_training
           __A		   =      use_input_mask
           __A		   =      use_token_type_ids
           __A		   =      use_labels
           __A		   =      vocab_size
           __A		   =      hidden_size
           __A		   =      input_embedding_size
           __A		   =      output_embedding_size
           __A		   =      num_hidden_layers
           __A		   =      num_attention_heads
           __A		   =      intermediate_size
           __A		   =      hidden_act
           __A		   =      hidden_dropout_prob
           __A		   =      attention_probs_dropout_prob
           __A		   =      max_position_embeddings
           __A		   =      type_vocab_size
           __A		   =      type_sequence_label_size
           __A		   =      initializer_range
           __A		   =      num_labels
           __A		   =      num_choices
           __A		   =      scope






     def     _UpperCamelCase   (self    :	int					)  ->       Union[str, Any]:
           __A		   =      ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size					)

           __A		   =      None
           if self.use_input_mask:
                 __A		   =      random_attention_mask([self.batch_size, self.seq_length]					)

           __A		   =      None
           if self.use_token_type_ids:
                 __A		   =      ids_tensor([self.batch_size, self.seq_length]				,				self.type_vocab_size					)

           __A		   =      None
           __A		   =      None
           __A		   =      None
           if self.use_labels:
                 __A		   =      ids_tensor([self.batch_size]				,				self.type_sequence_label_size					)
                 __A		   =      ids_tensor([self.batch_size, self.seq_length]				,				self.num_labels					)
                 __A		   =      ids_tensor([self.batch_size]				,				self.num_choices					)

           __A		   =      RemBertConfig(
               vocab_size=self.vocab_size				,				hidden_size=self.hidden_size				,				input_embedding_size=self.input_embedding_size				,				output_embedding_size=self.output_embedding_size				,				num_hidden_layers=self.num_hidden_layers				,				num_attention_heads=self.num_attention_heads				,				intermediate_size=self.intermediate_size				,				hidden_act=self.hidden_act				,				hidden_dropout_prob=self.hidden_dropout_prob				,				attention_probs_dropout_prob=self.attention_probs_dropout_prob				,				max_position_embeddings=self.max_position_embeddings				,				type_vocab_size=self.type_vocab_size				,				is_decoder=lowercase__				,				initializer_range=self.initializer_range				,				)

           return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Dict:
           (
               (
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,								
           )		   =      self.prepare_config_and_inputs()

           __A		   =      True
           __A		   =      floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
           __A		   =      ids_tensor([self.batch_size, self.seq_length]				,				vocab_size=2					)

           return (
               config,
               input_ids,
               token_type_ids,
               input_mask,
               sequence_labels,
               token_labels,
               choice_labels,
               encoder_hidden_states,
               encoder_attention_mask,
           )






     def     _UpperCamelCase   (self    :	Optional[int]				,				lowercase__    :	List[Any]				,				lowercase__    :	Any				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	Any				,				lowercase__    :	str				,				lowercase__    :	Any				,				lowercase__    :	List[Any]					)  ->       str:
           __A		   =      RemBertModel(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__					)
           __A		   =      model(lowercase__				,				token_type_ids=lowercase__					)
           __A		   =      model(lowercase__					)
           self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)					)






     def     _UpperCamelCase   (self    :	Dict				,				lowercase__    :	Tuple				,				lowercase__    :	Optional[int]				,				lowercase__    :	str				,				lowercase__    :	List[Any]				,				lowercase__    :	Tuple				,				lowercase__    :	List[Any]				,				lowercase__    :	Optional[Any]				,				lowercase__    :	int				,				lowercase__    :	List[str]				,				)  ->       Dict:
           __A		   =      True
           __A		   =      RemBertModel(lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				encoder_hidden_states=lowercase__				,				encoder_attention_mask=lowercase__				,				)
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				encoder_hidden_states=lowercase__				,				)
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__					)
           self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)					)






     def     _UpperCamelCase   (self    :	Optional[Any]				,				lowercase__    :	Dict				,				lowercase__    :	int				,				lowercase__    :	List[Any]				,				lowercase__    :	Optional[int]				,				lowercase__    :	str				,				lowercase__    :	Optional[Any]				,				lowercase__    :	Optional[Any]				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	Union[str, Any]				,				)  ->       List[str]:
           __A		   =      RemBertForCausalLM(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				labels=lowercase__					)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.vocab_size)					)






     def     _UpperCamelCase   (self    :	str				,				lowercase__    :	Tuple				,				lowercase__    :	List[Any]				,				lowercase__    :	List[Any]				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	int				,				lowercase__    :	Optional[Any]				,				lowercase__    :	Tuple					)  ->       str:
           __A		   =      RemBertForMaskedLM(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				labels=lowercase__					)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.vocab_size)					)






     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	Optional[int]				,				lowercase__    :	int				,				lowercase__    :	int				,				lowercase__    :	Dict				,				lowercase__    :	Tuple				,				lowercase__    :	Tuple				,				lowercase__    :	List[Any]				,				lowercase__    :	List[Any]				,				lowercase__    :	Dict				,				)  ->       Optional[int]:
           __A		   =      True
           __A		   =      True
           __A		   =      RemBertForCausalLM(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()

           # first forward pass
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				encoder_hidden_states=lowercase__				,				encoder_attention_mask=lowercase__				,				use_cache=lowercase__				,				)
           __A		   =      outputs.past_key_values

           # create hypothetical multiple next token and extent to next_input_ids
           __A		   =      ids_tensor((self.batch_size, 3)				,				config.vocab_size					)
           __A		   =      ids_tensor((self.batch_size, 3)				,				vocab_size=2					)

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

           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				encoder_hidden_states=lowercase__				,				encoder_attention_mask=lowercase__				,				output_hidden_states=lowercase__				,				)["hidden_states"][0]
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				encoder_hidden_states=lowercase__				,				encoder_attention_mask=lowercase__				,				past_key_values=lowercase__				,				output_hidden_states=lowercase__				,				)["hidden_states"][0]

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

           self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)

           # test that outputs are equal for slice
           self.parent.assertTrue(torch.allclose(lowercase__				,				lowercase__				,				atol=1e-3					)					)






     def     _UpperCamelCase   (self    :	Union[str, Any]				,				lowercase__    :	Optional[int]				,				lowercase__    :	int				,				lowercase__    :	List[str]				,				lowercase__    :	Optional[Any]				,				lowercase__    :	int				,				lowercase__    :	Tuple				,				lowercase__    :	Union[str, Any]					)  ->       Dict:
           __A		   =      RemBertForQuestionAnswering(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				start_positions=lowercase__				,				end_positions=lowercase__				,				)
           self.parent.assertEqual(result.start_logits.shape				,				(self.batch_size, self.seq_length)					)
           self.parent.assertEqual(result.end_logits.shape				,				(self.batch_size, self.seq_length)					)






     def     _UpperCamelCase   (self    :	Union[str, Any]				,				lowercase__    :	List[Any]				,				lowercase__    :	Dict				,				lowercase__    :	int				,				lowercase__    :	str				,				lowercase__    :	List[str]				,				lowercase__    :	Dict				,				lowercase__    :	Any					)  ->       Optional[Any]:
           __A		   =      self.num_labels
           __A		   =      RemBertForSequenceClassification(lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				labels=lowercase__					)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels)					)






     def     _UpperCamelCase   (self    :	Dict				,				lowercase__    :	Tuple				,				lowercase__    :	Any				,				lowercase__    :	Optional[Any]				,				lowercase__    :	Tuple				,				lowercase__    :	Union[str, Any]				,				lowercase__    :	Optional[int]				,				lowercase__    :	int					)  ->       Union[str, Any]:
           __A		   =      self.num_labels
           __A		   =      RemBertForTokenClassification(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      model(lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				labels=lowercase__					)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.num_labels)					)






     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	Tuple				,				lowercase__    :	Tuple				,				lowercase__    :	List[str]				,				lowercase__    :	int				,				lowercase__    :	Dict				,				lowercase__    :	Tuple				,				lowercase__    :	Any					)  ->       List[Any]:
           __A		   =      self.num_choices
           __A		   =      RemBertForMultipleChoice(config=lowercase__					)
           model.to(lowercase__					)
           model.eval()
           __A		   =      input_ids.unsqueeze(1					).expand(-1				,				self.num_choices				,				-1					).contiguous()
           __A		   =      token_type_ids.unsqueeze(1					).expand(-1				,				self.num_choices				,				-1					).contiguous()
           __A		   =      input_mask.unsqueeze(1					).expand(-1				,				self.num_choices				,				-1					).contiguous()
           __A		   =      model(
               lowercase__				,				attention_mask=lowercase__				,				token_type_ids=lowercase__				,				labels=lowercase__				,				)
           self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_choices)					)






     def     _UpperCamelCase   (self    :	Optional[int]					)  ->       Tuple:
           __A		   =      self.prepare_config_and_inputs()
           (
               (
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,								
           )		   =      config_and_inputs
           __A		   =      {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
           return config, inputs_dict







@require_torch
class 					a__    (			lowerCamelCase ,						lowerCamelCase ,						unittest.TestCase						):
     '''simple docstring'''







     _snake_case             =  (
         (
             RemBertModel,
             RemBertForMaskedLM,
             RemBertForCausalLM,
             RemBertForMultipleChoice,
             RemBertForQuestionAnswering,
             RemBertForSequenceClassification,
             RemBertForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     _snake_case             =  (RemBertForCausalLM,) if is_torch_available() else ()
     _snake_case             =  (
         {
             'feature-extraction': RemBertModel,
             'fill-mask': RemBertForMaskedLM,
             'question-answering': RemBertForQuestionAnswering,
             'text-classification': RemBertForSequenceClassification,
             'text-generation': RemBertForCausalLM,
             'token-classification': RemBertForTokenClassification,
             'zero-shot': RemBertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )






     def     _UpperCamelCase   (self    :	Tuple					)  ->       Any:
           __A		   =      RemBertModelTester(self					)
           __A		   =      ConfigTester(self				,				config_class=lowercase__				,				hidden_size=37					)






     def     _UpperCamelCase   (self    :	List[str]					)  ->       Optional[Any]:
           self.config_tester.run_common_tests()






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       List[str]:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Any:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           for type in ["absolute", "relative_key", "relative_key_query"]:
                 __A		   =      type
                 self.model_tester.create_and_check_model(*lowercase__					)






     def     _UpperCamelCase   (self    :	int					)  ->       str:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_lm(*lowercase__					)






     def     _UpperCamelCase   (self    :	int					)  ->       Union[str, Any]:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_multiple_choice(*lowercase__					)






     def     _UpperCamelCase   (self    :	Tuple					)  ->       Dict:
           __A		   =      self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_decoder_model_past_large_inputs(*lowercase__					)






     def     _UpperCamelCase   (self    :	int					)  ->       Optional[Any]:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_question_answering(*lowercase__					)






     def     _UpperCamelCase   (self    :	Union[str, Any]					)  ->       Optional[int]:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_sequence_classification(*lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Union[str, Any]:
           __A		   =      self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_token_classification(*lowercase__					)






     def     _UpperCamelCase   (self    :	Tuple					)  ->       List[str]:
           __A		   =      self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_model_as_decoder(*lowercase__					)






     def     _UpperCamelCase   (self    :	Optional[Any]					)  ->       Optional[int]:
           # This regression test was failing with PyTorch < 1.3
           (
               (
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,				(
               __A				
           )   ,								
           )		   =      self.model_tester.prepare_config_and_inputs_for_decoder()

           __A		   =      None

           self.model_tester.create_and_check_model_as_decoder(
               lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				lowercase__				,				)






     @slow
     def     _UpperCamelCase   (self    :	List[str]					)  ->       Optional[Any]:
           for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __A		   =      RemBertModel.from_pretrained(lowercase__					)
                 self.assertIsNotNone(lowercase__					)







@require_torch
class 					a__    (			unittest.TestCase						):
     '''simple docstring'''







     @slow
     def     _UpperCamelCase   (self    :	Dict					)  ->       Union[str, Any]:
           # Test exact values at the last hidden layer
           __A		   =      RemBertModel.from_pretrained("google/rembert"					)
           __A		   =      torch.tensor([[312, 56498, 313, 2125, 313]]					)
           __A		   =      torch.tensor([[0, 0, 0, 1, 1]]					)
           with torch.no_grad():
                 __A		   =      model(lowercase__				,				token_type_ids=lowercase__				,				output_hidden_states=lowercase__					)

           __A		   =      1152

           __A		   =      torch.Size((1, 5, hidden_size)					)
           self.assertEqual(output["last_hidden_state"].shape				,				lowercase__					)

           __A		   =      torch.tensor(
               [
                   [
                       [0.07_54, -0.20_22, 0.19_04],
                       [-0.33_54, -0.36_92, -0.47_91],
                       [-0.23_14, -0.67_29, -0.07_49],
                       [-0.03_96, -0.31_05, -0.42_34],
                       [-0.15_71, -0.05_25, 0.53_53],
                   ]
               ]					)

           # Running on the original tf implementation gives slightly different results here.
           # Not clear why this variations is present
           # TODO: Find reason for discrepancy
           # expected_original_implementation = [[
           #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
           #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
           #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
           #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
           #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
           # ]]

           self.assertTrue(torch.allclose(output["last_hidden_state"][:, :, :3]				,				lowercase__				,				atol=1e-4					)					)










'''simple docstring'''







from cva import destroyAllWindows, imread, imshow, waitKey


def 						_UpperCamelCase							(     snake_case__							,			snake_case__							):
      __A   ,				__A		   =      img.shape[0], img.shape[1]

      def to_grayscale(snake_case__							,			snake_case__							,			snake_case__							):
            return 0.2126 * red + 0.587 * green + 0.114 * blue

      def normalize(snake_case__							):
            return min(snake_case__							,			255							)

      for i in range(snake_case__							):
            for j in range(snake_case__							):
                  __A		   =      int(to_grayscale(*img[i][j]							)							)
                  __A		   =      [
                      normalize(snake_case__							),
                      normalize(greyscale + factor							),
                      normalize(greyscale + 2 * factor							),
                  ]

      return img


if __name__ == "__main__":
       # read original image
       __A      :       Dict      =	{
           percentage: imread('image_data/lena.jpg', 1) for percentage in (1_0, 2_0, 3_0, 4_0)
       }

       for percentage, img in images.items():
              make_sepia(img, percentage)

       for percentage, img in images.items():
              imshow(F"""Original image with sepia (factor: {percentage})""", img)

       waitKey(0)
       destroyAllWindows()


