'''simple docstring'''

import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel

       if is_vision_available():
              from transformers import MaskFormerImageProcessor

if is_vision_available():
       from PIL import Image





class 							lowercase						:


   def __init__(   self				:	Any   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	Dict=2   ,		__lowerCAmelCase				:	Union[str, Any]=True   ,		__lowerCAmelCase				:	List[str]=False   ,		__lowerCAmelCase				:	Dict=10   ,		__lowerCAmelCase				:	Any=3   ,		__lowerCAmelCase				:	List[str]=32 * 4   ,		__lowerCAmelCase				:	int=32 * 6   ,		__lowerCAmelCase				:	str=4   ,		__lowerCAmelCase				:	Tuple=32   ,		)      ->					Optional[Any]:
         lowercase_     =      parent
         lowercase_     =      batch_size
         lowercase_     =      is_training
         lowercase_     =      use_auxiliary_loss
         lowercase_     =      num_queries
         lowercase_     =      num_channels
         lowercase_     =      min_size
         lowercase_     =      max_size
         lowercase_     =      num_labels
         lowercase_     =      mask_feature_size


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					str:
         lowercase_     =      floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]).to(
             __lowerCAmelCase)

         lowercase_     =      torch.ones([self.batch_size, self.min_size, self.max_size]   ,		device=__lowerCAmelCase)

         lowercase_     =      (
             torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]   ,		device=__lowerCAmelCase) > 0.5
         ).float()
         lowercase_     =      (torch.rand((self.batch_size, self.num_labels)   ,		device=__lowerCAmelCase) > 0.5).long()

         lowercase_     =      self.get_config()
         return config, pixel_values, pixel_mask, mask_labels, class_labels


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Tuple:
         return MaskFormerConfig.from_backbone_and_decoder_configs(
             backbone_config=SwinConfig(
                 depths=[1, 1, 1, 1]   ,		)   ,		decoder_config=DetrConfig(
                 decoder_ffn_dim=128   ,		num_queries=self.num_queries   ,		decoder_attention_heads=2   ,		d_model=self.mask_feature_size   ,		)   ,		mask_feature_size=self.mask_feature_size   ,		fpn_feature_size=self.mask_feature_size   ,		num_channels=self.num_channels   ,		num_labels=self.num_labels   ,		)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					List[Any]:
         lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_     =      self.prepare_config_and_inputs()
         lowercase_     =      {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
         return config, inputs_dict


   def __UpperCAmelCase       (   self				:	Optional[Any]   ,		__lowerCAmelCase				:	str   ,		__lowerCAmelCase				:	Union[str, Any])      ->					Any:
         lowercase_     =      output.encoder_hidden_states
         lowercase_     =      output.pixel_decoder_hidden_states
         lowercase_     =      output.transformer_decoder_hidden_states

         self.parent.assertTrue(len(__lowerCAmelCase)   ,		len(config.backbone_config.depths))
         self.parent.assertTrue(len(__lowerCAmelCase)   ,		len(config.backbone_config.depths))
         self.parent.assertTrue(len(__lowerCAmelCase)   ,		config.decoder_config.decoder_layers)


   def __UpperCAmelCase       (   self				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	int=False)      ->					Tuple:
         with torch.no_grad():
               lowercase_     =      MaskFormerModel(config=__lowerCAmelCase)
               model.to(__lowerCAmelCase)
               model.eval()

               lowercase_     =      model(pixel_values=__lowerCAmelCase   ,		pixel_mask=__lowerCAmelCase)
               lowercase_     =      model(__lowerCAmelCase   ,		output_hidden_states=__lowerCAmelCase)
         # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
         # encoder and pixel decoder
         self.parent.assertEqual(
             output.transformer_decoder_last_hidden_state.shape   ,		(self.batch_size, self.num_queries, self.mask_feature_size)   ,		)
         # let's ensure the other two hidden state exists
         self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None)
         self.parent.assertTrue(output.encoder_last_hidden_state is not None)

         if output_hidden_states:
               self.check_output_hidden_state(__lowerCAmelCase   ,		__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[str]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Any   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	List[str]   ,		__lowerCAmelCase				:	str)      ->					Optional[int]:
         lowercase_     =      MaskFormerForInstanceSegmentation(config=__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         def comm_check_on_output(__lowerCAmelCase				:	Any):
               # let's still check that all the required stuff is there
               self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None)
               self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None)
               self.parent.assertTrue(result.encoder_last_hidden_state is not None)
               # okay, now we need to check the logits shape
               # due to the encoder compression, masks have a //4 spatial size
               self.parent.assertEqual(
                   result.masks_queries_logits.shape   ,		(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)   ,		)
               # + 1 for null class
               self.parent.assertEqual(
                   result.class_queries_logits.shape   ,		(self.batch_size, self.num_queries, self.num_labels + 1))

         with torch.no_grad():
               lowercase_     =      model(pixel_values=__lowerCAmelCase   ,		pixel_mask=__lowerCAmelCase)
               lowercase_     =      model(__lowerCAmelCase)

               comm_check_on_output(__lowerCAmelCase)

               lowercase_     =      model(
                   pixel_values=__lowerCAmelCase   ,		pixel_mask=__lowerCAmelCase   ,		mask_labels=__lowerCAmelCase   ,		class_labels=__lowerCAmelCase)

         comm_check_on_output(__lowerCAmelCase)

         self.parent.assertTrue(result.loss is not None)
         self.parent.assertEqual(result.loss.shape   ,		torch.Size([1]))





@require_torch
class 							lowercase						(						__lowerCamelCase ,				__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
   lowerCamelCase_    					=(
       {'feature-extraction': MaskFormerModel, 'image-segmentation': MaskFormerForInstanceSegmentation}
       if is_torch_available()
       else {}
   )

   lowerCamelCase_    					=False
   lowerCamelCase_    					=False
   lowerCamelCase_    					=False
   lowerCamelCase_    					=False


   def __UpperCAmelCase       (   self				:	List[str])      ->					int:
         lowercase_     =      MaskFormerModelTester(self)
         lowercase_     =      ConfigTester(self   ,		config_class=__lowerCAmelCase   ,		has_text_modality=__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					str:
         self.config_tester.run_common_tests()


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					List[Any]:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase   ,		**__lowerCAmelCase   ,		output_hidden_states=__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	List[Any])      ->					Any:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*__lowerCAmelCase)


   @unittest.skip(reason="MaskFormer does not use inputs_embeds")
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					List[str]:
         pass


   @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method")
   def __UpperCAmelCase       (   self				:	str)      ->					Tuple:
         pass


   @unittest.skip(reason="MaskFormer is not a generative model")
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Any:
         pass


   @unittest.skip(reason="MaskFormer does not use token embeddings")
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Dict:
         pass


   @require_torch_multi_gpu
   @unittest.skip(
       reason="MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`")
   def __UpperCAmelCase       (   self				:	Any)      ->					Dict:
         pass


   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
   def __UpperCAmelCase       (   self				:	str)      ->					List[str]:
         pass


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Union[str, Any]:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()

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

               lowercase_     =      ["pixel_values"]
               self.assertListEqual(arg_names[:1]   ,		__lowerCAmelCase)


   @slow
   def __UpperCAmelCase       (   self				:	int)      ->					Optional[int]:
         for model_name in ["facebook/maskformer-swin-small-coco"]:
               lowercase_     =      MaskFormerModel.from_pretrained(__lowerCAmelCase)
               self.assertIsNotNone(__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	str)      ->					List[Any]:
         lowercase_     =      (self.model_tester.min_size,) * 2
         lowercase_     =      {
             "pixel_values": torch.randn((2, 3, *size)   ,		device=__lowerCAmelCase),
             "mask_labels": torch.randn((2, 10, *size)   ,		device=__lowerCAmelCase),
             "class_labels": torch.zeros(2   ,		10   ,		device=__lowerCAmelCase).long(),
         }

         lowercase_     =      MaskFormerForInstanceSegmentation(MaskFormerConfig()).to(__lowerCAmelCase)
         lowercase_     =      model(**__lowerCAmelCase)
         self.assertTrue(outputs.loss is not None)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					str:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase   ,		**__lowerCAmelCase   ,		output_hidden_states=__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Any)      ->					List[str]:
         lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
               lowercase_     =      model_class(__lowerCAmelCase).to(__lowerCAmelCase)
               lowercase_     =      model(**__lowerCAmelCase   ,		output_attentions=__lowerCAmelCase)
               self.assertTrue(outputs.attentions is not None)


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					Any:
         if not self.model_tester.is_training:
               return
         # only MaskFormerForInstanceSegmentation has the loss
         lowercase_     =      self.all_model_classes[1]
         lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs()

         lowercase_     =      model_class(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.train()

         lowercase_     =      model(__lowerCAmelCase   ,		mask_labels=__lowerCAmelCase   ,		class_labels=__lowerCAmelCase).loss
         loss.backward()


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Optional[int]:
         # only MaskFormerForInstanceSegmentation has the loss
         lowercase_     =      self.all_model_classes[1]
         lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_ ,							lowercase_     =      self.model_tester.prepare_config_and_inputs()
         lowercase_     =      True
         lowercase_     =      True

         lowercase_     =      model_class(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.train()

         lowercase_     =      model(__lowerCAmelCase   ,		mask_labels=__lowerCAmelCase   ,		class_labels=__lowerCAmelCase)

         lowercase_     =      outputs.encoder_hidden_states[0]
         encoder_hidden_states.retain_grad()

         lowercase_     =      outputs.pixel_decoder_hidden_states[0]
         pixel_decoder_hidden_states.retain_grad()
         # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
         lowercase_     =      outputs.transformer_decoder_hidden_states[0]
         transformer_decoder_hidden_states.retain_grad()

         lowercase_     =      outputs.attentions[0]
         attentions.retain_grad()

         outputs.loss.backward(retain_graph=__lowerCAmelCase)

         self.assertIsNotNone(encoder_hidden_states.grad)
         self.assertIsNotNone(pixel_decoder_hidden_states.grad)
         self.assertIsNotNone(transformer_decoder_hidden_states.grad)
         self.assertIsNotNone(attentions.grad)




lowerCAmelCase_ : Dict						  =      1E-4


def __a (	)	->							List[str]:
      '''simple docstring'''


      lowercase_     =      Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
      return image






@require_vision
@slow
class 							lowercase						(						unittest.TestCase ):


   @cached_property
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					List[Any]:
         return (
             MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco")
             if is_vision_available()
             else None
         )


   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Optional[int]:
         lowercase_     =      MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco").to(__lowerCAmelCase)
         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(__lowerCAmelCase   ,		return_tensors="pt").to(__lowerCAmelCase)
         lowercase_     =      inputs["pixel_values"].shape
         # check size is divisible by 32
         self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0)
         # check size
         self.assertEqual(__lowerCAmelCase   ,		(1, 3, 800, 1088))

         with torch.no_grad():
               lowercase_     =      model(**__lowerCAmelCase)

         lowercase_     =      torch.tensor(
             [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]).to(__lowerCAmelCase)
         self.assertTrue(
             torch.allclose(
                 outputs.encoder_last_hidden_state[0, 0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))

         lowercase_     =      torch.tensor(
             [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]).to(__lowerCAmelCase)
         self.assertTrue(
             torch.allclose(
                 outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))

         lowercase_     =      torch.tensor(
             [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]).to(__lowerCAmelCase)
         self.assertTrue(
             torch.allclose(
                 outputs.transformer_decoder_last_hidden_state[0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))


   def __UpperCAmelCase       (   self				:	List[str])      ->					List[Any]:
         lowercase_     =      (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco")
             .to(__lowerCAmelCase)
             .eval()
         )
         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(__lowerCAmelCase   ,		return_tensors="pt").to(__lowerCAmelCase)
         lowercase_     =      inputs["pixel_values"].shape
         # check size is divisible by 32
         self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0)
         # check size
         self.assertEqual(__lowerCAmelCase   ,		(1, 3, 800, 1088))

         with torch.no_grad():
               lowercase_     =      model(**__lowerCAmelCase)
         # masks_queries_logits
         lowercase_     =      outputs.masks_queries_logits
         self.assertEqual(
             masks_queries_logits.shape   ,		(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)   ,		)
         lowercase_     =      [
             [-1.373_7124, -1.772_4937, -1.936_4233],
             [-1.597_7281, -1.986_7939, -2.152_3695],
             [-1.579_5398, -1.926_9832, -2.09_3942],
         ]
         lowercase_     =      torch.tensor(__lowerCAmelCase).to(__lowerCAmelCase)
         self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))
         # class_queries_logits
         lowercase_     =      outputs.class_queries_logits
         self.assertEqual(
             class_queries_logits.shape   ,		(1, model.config.decoder_config.num_queries, model.config.num_labels + 1))
         lowercase_     =      torch.tensor(
             [
                 [1.65_12e00, -5.25_72e00, -3.35_19e00],
                 [3.61_69e-02, -5.90_25e00, -2.93_13e00],
                 [1.07_66e-04, -7.76_30e00, -5.12_63e00],
             ]).to(__lowerCAmelCase)
         self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))


   def __UpperCAmelCase       (   self				:	List[Any])      ->					Any:
         lowercase_     =      (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff")
             .to(__lowerCAmelCase)
             .eval()
         )
         lowercase_     =      self.default_image_processor
         lowercase_     =      prepare_img()
         lowercase_     =      image_processor(__lowerCAmelCase   ,		return_tensors="pt").to(__lowerCAmelCase)
         lowercase_     =      inputs["pixel_values"].shape
         # check size is divisible by 32
         self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0)
         # check size
         self.assertEqual(__lowerCAmelCase   ,		(1, 3, 800, 1088))

         with torch.no_grad():
               lowercase_     =      model(**__lowerCAmelCase)
         # masks_queries_logits
         lowercase_     =      outputs.masks_queries_logits
         self.assertEqual(
             masks_queries_logits.shape   ,		(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)   ,		)
         lowercase_     =      [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
         lowercase_     =      torch.tensor(__lowerCAmelCase).to(__lowerCAmelCase)
         self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))
         # class_queries_logits
         lowercase_     =      outputs.class_queries_logits
         self.assertEqual(
             class_queries_logits.shape   ,		(1, model.config.decoder_config.num_queries, model.config.num_labels + 1))
         lowercase_     =      torch.tensor(
             [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]).to(__lowerCAmelCase)
         self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]   ,		__lowerCAmelCase   ,		atol=__lowerCAmelCase))


   def __UpperCAmelCase       (   self				:	int)      ->					Dict:
         lowercase_     =      (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco")
             .to(__lowerCAmelCase)
             .eval()
         )
         lowercase_     =      self.default_image_processor

         lowercase_     =      image_processor(
             [np.zeros((3, 800, 1333)), np.zeros((3, 800, 1333))]   ,		segmentation_maps=[np.zeros((384, 384)).astype(np.floataa), np.zeros((384, 384)).astype(np.floataa)]   ,		return_tensors="pt"   ,		)

         lowercase_     =      inputs["pixel_values"].to(__lowerCAmelCase)
         lowercase_     =      [el.to(__lowerCAmelCase) for el in inputs["mask_labels"]]
         lowercase_     =      [el.to(__lowerCAmelCase) for el in inputs["class_labels"]]

         with torch.no_grad():
               lowercase_     =      model(**__lowerCAmelCase)

         self.assertTrue(outputs.loss is not None)







'''simple docstring'''

import gc
import unittest

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

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


if is_torch_available():
       import torch

       from transformers import (
           CTRL_PRETRAINED_MODEL_ARCHIVE_LIST,
           CTRLForSequenceClassification,
           CTRLLMHeadModel,
           CTRLModel,
       )





class 							lowercase						:


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


   def __UpperCAmelCase       (   self				:	Tuple)      ->					int:
         lowercase_     =      ids_tensor([self.batch_size, self.seq_length]   ,		self.vocab_size)

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

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

         lowercase_     =      None
         if self.use_mc_token_ids:
               lowercase_     =      ids_tensor([self.batch_size, self.num_choices]   ,		self.seq_length)

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

         lowercase_     =      self.get_config()

         lowercase_     =      ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,		2)

         return (
             config,
             input_ids,
             input_mask,
             head_mask,
             token_type_ids,
             mc_token_ids,
             sequence_labels,
             token_labels,
             choice_labels,
         )


   def __UpperCAmelCase       (   self				:	Union[str, Any])      ->					int:
         return CTRLConfig(
             vocab_size=self.vocab_size   ,		n_embd=self.hidden_size   ,		n_layer=self.num_hidden_layers   ,		n_head=self.num_attention_heads   ,		n_positions=self.max_position_embeddings   ,		pad_token_id=self.pad_token_id   ,		)


   def __UpperCAmelCase       (   self				:	Union[str, Any]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Tuple   ,		__lowerCAmelCase				:	Union[str, Any]   ,		*__lowerCAmelCase				:	Tuple)      ->					List[str]:
         lowercase_     =      CTRLModel(config=__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		head_mask=__lowerCAmelCase)
         model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase)
         lowercase_     =      model(__lowerCAmelCase)
         self.parent.assertEqual(result.last_hidden_state.shape   ,		(self.batch_size, self.seq_length, self.hidden_size))
         self.parent.assertEqual(len(result.past_key_values)   ,		config.n_layer)


   def __UpperCAmelCase       (   self				:	List[Any]   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Union[str, Any]   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	Dict   ,		*__lowerCAmelCase				:	int)      ->					int:
         lowercase_     =      CTRLLMHeadModel(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()

         lowercase_     =      model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		labels=__lowerCAmelCase)
         self.parent.assertEqual(result.loss.shape   ,		())
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.seq_length, self.vocab_size))


   def __UpperCAmelCase       (   self				:	Dict)      ->					int:
         lowercase_     =      self.prepare_config_and_inputs()

         (
             (
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							(
             lowercase_
         ) ,							
         )     =      config_and_inputs

         lowercase_     =      {"input_ids": input_ids, "token_type_ids": token_type_ids, "head_mask": head_mask}

         return config, inputs_dict


   def __UpperCAmelCase       (   self				:	Any   ,		__lowerCAmelCase				:	Optional[int]   ,		__lowerCAmelCase				:	Optional[Any]   ,		__lowerCAmelCase				:	int   ,		__lowerCAmelCase				:	List[str]   ,		*__lowerCAmelCase				:	List[Any])      ->					int:
         lowercase_     =      self.num_labels
         lowercase_     =      CTRLForSequenceClassification(__lowerCAmelCase)
         model.to(__lowerCAmelCase)
         model.eval()
         lowercase_     =      ids_tensor([self.batch_size]   ,		self.type_sequence_label_size)
         lowercase_     =      model(__lowerCAmelCase   ,		token_type_ids=__lowerCAmelCase   ,		labels=__lowerCAmelCase)
         self.parent.assertEqual(result.logits.shape   ,		(self.batch_size, self.num_labels))





@require_torch
class 							lowercase						(						__lowerCamelCase ,				__lowerCamelCase ,				__lowerCamelCase ,				unittest.TestCase ):
   lowerCamelCase_    					=(CTRLModel, CTRLLMHeadModel, CTRLForSequenceClassification) if is_torch_available() else ()
   lowerCamelCase_    					=(CTRLLMHeadModel,) if is_torch_available() else ()
   lowerCamelCase_    					=(
       {
           'feature-extraction': CTRLModel,
           'text-classification': CTRLForSequenceClassification,
           'text-generation': CTRLLMHeadModel,
           'zero-shot': CTRLForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   lowerCamelCase_    					=True
   lowerCamelCase_    					=False
   lowerCamelCase_    					=False


   def __UpperCAmelCase       (   self				:	Tuple   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	Dict   ,		__lowerCAmelCase				:	str   ,		__lowerCAmelCase				:	List[Any]   ,		__lowerCAmelCase				:	int)      ->					Optional[int]:
         if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
               # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
               # `CTRLConfig` was never used in pipeline tests, either because of a missing checkpoint or because a tiny
               # config could not be created.
               return True

         return False


   def __UpperCAmelCase       (   self				:	str)      ->					Tuple:
         lowercase_     =      CTRLModelTester(self)
         lowercase_     =      ConfigTester(self   ,		config_class=__lowerCAmelCase   ,		n_embd=37)


   def __UpperCAmelCase       (   self				:	Dict)      ->					Optional[Any]:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


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


   def __UpperCAmelCase       (   self				:	Any)      ->					List[Any]:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_ctrl_model(*__lowerCAmelCase)


   def __UpperCAmelCase       (   self				:	Tuple)      ->					Dict:
         lowercase_     =      self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_lm_head_model(*__lowerCAmelCase)


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


   @slow
   def __UpperCAmelCase       (   self				:	Dict)      ->					List[str]:
         for model_name in CTRL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               lowercase_     =      CTRLModel.from_pretrained(__lowerCAmelCase)
               self.assertIsNotNone(__lowerCAmelCase)


   @unittest.skip("The model doesn't support left padding")  # and it's not used enough to be worth fixing :)
   def __UpperCAmelCase       (   self				:	Optional[Any])      ->					Dict:
         pass





@require_torch
class 							lowercase						(						unittest.TestCase ):


   def __UpperCAmelCase       (   self				:	Optional[int])      ->					Any:
         super().tearDown()
         # clean-up as much as possible GPU memory occupied by PyTorch
         gc.collect()
         torch.cuda.empty_cache()


   @slow
   def __UpperCAmelCase       (   self				:	int)      ->					Any:
         lowercase_     =      CTRLLMHeadModel.from_pretrained("ctrl")
         model.to(__lowerCAmelCase)
         lowercase_     =      torch.tensor(
             [[1_1859, 0, 1611, 8]]   ,		dtype=torch.long   ,		device=__lowerCAmelCase)  # Legal the president is
         lowercase_     =      [
             1_1859,
             0,
             1611,
             8,
             5,
             150,
             2_6449,
             2,
             19,
             348,
             469,
             3,
             2595,
             48,
             2_0740,
             24_6533,
             24_6533,
             19,
             30,
             5,
         ]  # Legal the president is a good guy and I don't want to lose my job. \n \n I have a

         lowercase_     =      model.generate(__lowerCAmelCase   ,		do_sample=__lowerCAmelCase)
         self.assertListEqual(output_ids[0].tolist()   ,		__lowerCAmelCase)






