

'''simple docstring'''






import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import (
    DiffusionPipeline,
    UnCLIPImageVariationPipeline,
    UnCLIPScheduler,
    UNetaDConditionModel,
    UNetaDModel,
)
from diffusers.pipelines.unclip.text_proj import UnCLIPTextProjModel
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, load_image, require_torch_gpu, skip_mps

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()






class     lowercase_			(lowerCamelCase__       , unittest.TestCase   ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE					:						Optional[Any]           =    UnCLIPImageVariationPipeline
  SCREAMING_SNAKE_CASE					:						int           =    IMAGE_VARIATION_PARAMS - {'height', 'width', 'guidance_scale'}
  SCREAMING_SNAKE_CASE					:						Any           =    IMAGE_VARIATION_BATCH_PARAMS

  SCREAMING_SNAKE_CASE					:						List[Any]           =    [
      'generator',
      'return_dict',
      'decoder_num_inference_steps',
      'super_res_num_inference_steps',
  ]
  SCREAMING_SNAKE_CASE					:						str           =    False






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[Any]    ):
   return 3_2






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   return 3_2






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   return self.time_input_dim






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   return self.time_input_dim * 4






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   return 1_0_0






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''    )
   return tokenizer






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   torch.manual_seed(0    )
   __lowercase													=				CLIPTextConfig(
       bos_token_id=0      ,eos_token_id=2      ,hidden_size=self.text_embedder_hidden_size      ,projection_dim=self.text_embedder_hidden_size      ,intermediate_size=3_7      ,layer_norm_eps=1e-0_5      ,num_attention_heads=4      ,num_hidden_layers=5      ,pad_token_id=1      ,vocab_size=1_0_0_0      ,)
   return CLIPTextModelWithProjection(lowercase__    )






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   torch.manual_seed(0    )
   __lowercase													=				CLIPVisionConfig(
       hidden_size=self.text_embedder_hidden_size      ,projection_dim=self.text_embedder_hidden_size      ,num_hidden_layers=5      ,num_attention_heads=4      ,image_size=3_2      ,intermediate_size=3_7      ,patch_size=1      ,)
   return CLIPVisionModelWithProjection(lowercase__    )






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[Any]    ):
   torch.manual_seed(0    )

   __lowercase													=				{
       '''clip_embeddings_dim''': self.text_embedder_hidden_size,
       '''time_embed_dim''': self.time_embed_dim,
       '''cross_attention_dim''': self.cross_attention_dim,
   }

   __lowercase													=				UnCLIPTextProjModel(**lowercase__    )
   return model






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
   torch.manual_seed(0    )

   __lowercase													=				{
       '''sample_size''': 3_2,
       # RGB in channels
       '''in_channels''': 3,
       # Out channels is double in channels because predicts mean and variance
       '''out_channels''': 6,
       '''down_block_types''': ('''ResnetDownsampleBlock2D''', '''SimpleCrossAttnDownBlock2D'''),
       '''up_block_types''': ('''SimpleCrossAttnUpBlock2D''', '''ResnetUpsampleBlock2D'''),
       '''mid_block_type''': '''UNetMidBlock2DSimpleCrossAttn''',
       '''block_out_channels''': (self.block_out_channels_a, self.block_out_channels_a * 2),
       '''layers_per_block''': 1,
       '''cross_attention_dim''': self.cross_attention_dim,
       '''attention_head_dim''': 4,
       '''resnet_time_scale_shift''': '''scale_shift''',
       '''class_embed_type''': '''identity''',
   }

   __lowercase													=				UNetaDConditionModel(**lowercase__    )
   return model






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   return {
       "sample_size": 6_4,
       "layers_per_block": 1,
       "down_block_types": ("ResnetDownsampleBlock2D", "ResnetDownsampleBlock2D"),
       "up_block_types": ("ResnetUpsampleBlock2D", "ResnetUpsampleBlock2D"),
       "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
       "in_channels": 6,
       "out_channels": 3,
   }






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   torch.manual_seed(0    )

   __lowercase													=				UNetaDModel(**self.dummy_super_res_kwargs    )
   return model






  @property
  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   # seeded differently to get different unet than `self.dummy_super_res_first`
   torch.manual_seed(1    )

   __lowercase													=				UNetaDModel(**self.dummy_super_res_kwargs    )
   return model






  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   __lowercase													=				self.dummy_decoder
   __lowercase													=				self.dummy_text_proj
   __lowercase													=				self.dummy_text_encoder
   __lowercase													=				self.dummy_tokenizer
   __lowercase													=				self.dummy_super_res_first
   __lowercase													=				self.dummy_super_res_last

   __lowercase													=				UnCLIPScheduler(
       variance_type='''learned_range'''      ,prediction_type='''epsilon'''      ,num_train_timesteps=1_0_0_0      ,)

   __lowercase													=				UnCLIPScheduler(
       variance_type='''fixed_small_log'''      ,prediction_type='''epsilon'''      ,num_train_timesteps=1_0_0_0      ,)

   __lowercase													=				CLIPImageProcessor(crop_size=3_2      ,size=3_2    )

   __lowercase													=				self.dummy_image_encoder

   return {
       "decoder": decoder,
       "text_encoder": text_encoder,
       "tokenizer": tokenizer,
       "text_proj": text_proj,
       "feature_extractor": feature_extractor,
       "image_encoder": image_encoder,
       "super_res_first": super_res_first,
       "super_res_last": super_res_last,
       "decoder_scheduler": decoder_scheduler,
       "super_res_scheduler": super_res_scheduler,
   }






  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]      ,lowercase__     :  int      ,lowercase__     :  List[str]=0      ,lowercase__     :  str=True    ):
   __lowercase													=				floats_tensor((1, 3, 3_2, 3_2)      ,rng=random.Random(lowercase__    )    ).to(lowercase__    )
   if str(lowercase__    ).startswith('''mps'''    ):
    __lowercase													=				torch.manual_seed(lowercase__    )
   else:
    __lowercase													=				torch.Generator(device=lowercase__    ).manual_seed(lowercase__    )

   if pil_image:
    __lowercase													=				input_image * 0.5 + 0.5
    __lowercase													=				input_image.clamp(0      ,1    )
    __lowercase													=				input_image.cpu().permute(0      ,2      ,3      ,1    ).float().numpy()
    __lowercase													=				DiffusionPipeline.numpy_to_pil(lowercase__    )[0]

   return {
       "image": input_image,
       "generator": generator,
       "decoder_num_inference_steps": 2,
       "super_res_num_inference_steps": 2,
       "output_type": "np",
   }






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				'''cpu'''

   __lowercase													=				self.get_dummy_components()

   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )

   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )

   __lowercase													=				pipe(**lowercase__    )
   __lowercase													=				output.images

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )

   __lowercase													=				pipe(
       **lowercase__      ,return_dict=lowercase__      ,)[0]

   __lowercase													=				image[0, -3:, -3:, -1]
   __lowercase													=				image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 6_4, 6_4, 3)

   __lowercase													=				np.array(
       [
           0.9_9_9_7,
           0.0_0_0_2,
           0.9_9_9_7,
           0.9_9_9_7,
           0.9_9_6_9,
           0.0_0_2_3,
           0.9_9_9_7,
           0.9_9_6_9,
           0.9_9_7_0,
       ]    )

   assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
   assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2






  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   __lowercase													=				'''cpu'''

   __lowercase													=				self.get_dummy_components()

   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )

   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )

   __lowercase													=				pipe(**lowercase__    )
   __lowercase													=				output.images

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )

   __lowercase													=				pipe(
       **lowercase__      ,return_dict=lowercase__      ,)[0]

   __lowercase													=				image[0, -3:, -3:, -1]
   __lowercase													=				image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (1, 6_4, 6_4, 3)

   __lowercase													=				np.array([0.9_9_9_7, 0.0_0_0_3, 0.9_9_9_7, 0.9_9_9_7, 0.9_9_7_0, 0.0_0_2_4, 0.9_9_9_7, 0.9_9_7_1, 0.9_9_7_1]    )

   assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
   assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				'''cpu'''

   __lowercase													=				self.get_dummy_components()

   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )

   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )
   __lowercase													=				[
       pipeline_inputs['''image'''],
       pipeline_inputs['''image'''],
   ]

   __lowercase													=				pipe(**lowercase__    )
   __lowercase													=				output.images

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )
   __lowercase													=				[
       tuple_pipeline_inputs['''image'''],
       tuple_pipeline_inputs['''image'''],
   ]

   __lowercase													=				pipe(
       **lowercase__      ,return_dict=lowercase__      ,)[0]

   __lowercase													=				image[0, -3:, -3:, -1]
   __lowercase													=				image_from_tuple[0, -3:, -3:, -1]

   assert image.shape == (2, 6_4, 6_4, 3)

   __lowercase													=				np.array(
       [
           0.9_9_9_7,
           0.9_9_8_9,
           0.0_0_0_8,
           0.0_0_2_1,
           0.9_9_6_0,
           0.0_0_1_8,
           0.0_0_1_4,
           0.0_0_0_2,
           0.9_9_3_3,
       ]    )

   assert np.abs(image_slice.flatten() - expected_slice    ).max() < 1e-2
   assert np.abs(image_from_tuple_slice.flatten() - expected_slice    ).max() < 1e-2






  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[Any]    ):
   __lowercase													=				torch.device('''cpu'''    )






   class     lowercase_			:




     """simple docstring"""




     SCREAMING_SNAKE_CASE					:						List[str]           =    1
   __lowercase													=				self.get_dummy_components()

   __lowercase													=				self.pipeline_class(**lowercase__    )
   __lowercase													=				pipe.to(lowercase__    )

   pipe.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				torch.Generator(device=lowercase__    ).manual_seed(0    )
   __lowercase													=				pipe.decoder.dtype
   __lowercase													=				1

   __lowercase													=				(
       batch_size,
       pipe.decoder.config.in_channels,
       pipe.decoder.config.sample_size,
       pipe.decoder.config.sample_size,
   )
   __lowercase													=				pipe.prepare_latents(
       lowercase__      ,dtype=lowercase__      ,device=lowercase__      ,generator=lowercase__      ,latents=lowercase__      ,scheduler=DummyScheduler()    )

   __lowercase													=				(
       batch_size,
       pipe.super_res_first.config.in_channels // 2,
       pipe.super_res_first.config.sample_size,
       pipe.super_res_first.config.sample_size,
   )
   __lowercase													=				pipe.prepare_latents(
       lowercase__      ,dtype=lowercase__      ,device=lowercase__      ,generator=lowercase__      ,latents=lowercase__      ,scheduler=DummyScheduler()    )

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )

   __lowercase													=				pipe(
       **lowercase__      ,decoder_latents=lowercase__      ,super_res_latents=lowercase__    ).images

   __lowercase													=				self.get_dummy_inputs(lowercase__      ,pil_image=lowercase__    )
   # Don't pass image, instead pass embedding
   __lowercase													=				pipeline_inputs.pop('''image'''    )
   __lowercase													=				pipe.image_encoder(lowercase__    ).image_embeds

   __lowercase													=				pipe(
       **lowercase__      ,decoder_latents=lowercase__      ,super_res_latents=lowercase__      ,image_embeddings=lowercase__      ,).images

   # make sure passing text embeddings manually is identical
   assert np.abs(img_out_a - img_out_a    ).max() < 1e-4






  @skip_mps
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				torch_device == '''cpu'''

   # Check is relaxed because there is not a torch 2.0 sliced attention added kv processor
   __lowercase													=				1e-2

   self._test_attention_slicing_forward_pass(
       test_max_difference=lowercase__      ,expected_max_diff=lowercase__    )






  @skip_mps
  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				torch_device == '''cpu'''
   __lowercase													=				True
   __lowercase													=				[
       '''decoder_num_inference_steps''',
       '''super_res_num_inference_steps''',
   ]

   self._test_inference_batch_single_identical(
       test_max_difference=lowercase__      ,relax_max_difference=lowercase__      ,additional_params_copy_to_batched_inputs=lowercase__      ,)






  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				[
       '''decoder_num_inference_steps''',
       '''super_res_num_inference_steps''',
   ]

   if torch_device == "mps":
    # TODO: MPS errors with larger batch sizes
    __lowercase													=				[2, 3]
    self._test_inference_batch_consistent(
        batch_sizes=lowercase__      ,additional_params_copy_to_batched_inputs=lowercase__      ,)
   else:
    self._test_inference_batch_consistent(
        additional_params_copy_to_batched_inputs=lowercase__    )






  @skip_mps
  def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
   return super().test_dict_tuple_outputs_equivalent()






  @skip_mps
  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   return super().test_save_load_local()






  @skip_mps
  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   return super().test_save_load_optional_components()






@slow
@require_torch_gpu
class     lowercase_			(unittest.TestCase   ):




  """simple docstring"""




  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   # clean up the VRAM after each test
   super().tearDown()
   gc.collect()
   torch.cuda.empty_cache()






  def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
   __lowercase													=				load_image(
       '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/unclip/cat.png'''    )
   __lowercase													=				load_numpy(
       '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
       '''/unclip/karlo_v1_alpha_cat_variation_fp16.npy'''    )

   __lowercase													=				UnCLIPImageVariationPipeline.from_pretrained(
       '''kakaobrain/karlo-v1-alpha-image-variations'''      ,torch_dtype=torch.floataa    )
   __lowercase													=				pipeline.to(lowercase__    )
   pipeline.set_progress_bar_config(disable=lowercase__    )

   __lowercase													=				torch.Generator(device='''cpu'''    ).manual_seed(0    )
   __lowercase													=				pipeline(
       lowercase__      ,generator=lowercase__      ,output_type='''np'''      ,)

   __lowercase													=				output.images[0]

   assert image.shape == (2_5_6, 2_5_6, 3)

   assert_mean_pixel_difference(lowercase__      ,lowercase__      ,1_5    )




'''simple docstring'''






from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TFFunnelBaseModel,
     TFFunnelForMaskedLM,
     TFFunnelForMultipleChoice,
     TFFunnelForPreTraining,
     TFFunnelForQuestionAnswering,
     TFFunnelForSequenceClassification,
     TFFunnelForTokenClassification,
     TFFunnelModel,
 )






class     lowercase_			:




  """simple docstring"""




  def __init__(   self     :  Union[str, Any]      ,lowercase__     :  Union[str, Any]      ,lowercase__     :  List[Any]=1_3      ,lowercase__     :  Union[str, Any]=7      ,lowercase__     :  List[Any]=True      ,lowercase__     :  str=True      ,lowercase__     :  Any=True      ,lowercase__     :  Union[str, Any]=True      ,lowercase__     :  Tuple=9_9      ,lowercase__     :  List[str]=[1, 1, 2]      ,lowercase__     :  List[Any]=1      ,lowercase__     :  List[Any]=3_2      ,lowercase__     :  int=4      ,lowercase__     :  Tuple=8      ,lowercase__     :  Tuple=3_7      ,lowercase__     :  str="gelu_new"      ,lowercase__     :  Dict=0.1      ,lowercase__     :  Optional[int]=0.1      ,lowercase__     :  Optional[Any]=0.0      ,lowercase__     :  Tuple=5_1_2      ,lowercase__     :  Any=3      ,lowercase__     :  List[str]=0.0_2      ,lowercase__     :  List[Any]=3      ,lowercase__     :  List[Any]=4      ,lowercase__     :  Optional[Any]=None      ,lowercase__     :  Tuple=False      ,):
   __lowercase													=				parent
   __lowercase													=				batch_size
   __lowercase													=				seq_length
   __lowercase													=				is_training
   __lowercase													=				use_input_mask
   __lowercase													=				use_token_type_ids
   __lowercase													=				use_labels
   __lowercase													=				vocab_size
   __lowercase													=				block_sizes
   __lowercase													=				num_decoder_layers
   __lowercase													=				d_model
   __lowercase													=				n_head
   __lowercase													=				d_head
   __lowercase													=				d_inner
   __lowercase													=				hidden_act
   __lowercase													=				hidden_dropout
   __lowercase													=				attention_dropout
   __lowercase													=				activation_dropout
   __lowercase													=				max_position_embeddings
   __lowercase													=				type_vocab_size
   __lowercase													=				2
   __lowercase													=				num_labels
   __lowercase													=				num_choices
   __lowercase													=				scope
   __lowercase													=				initializer_std

   # Used in the tests to check the size of the first attention layer
   __lowercase													=				n_head
   # Used in the tests to check the size of the first hidden state
   __lowercase													=				self.d_model
   # Used in the tests to check the number of output hidden states/attentions
   __lowercase													=				sum(self.block_sizes    ) + (0 if base else self.num_decoder_layers)
   # FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
   # the last hidden state of the first block (which is the first hidden state of the decoder).
   if not base:
    __lowercase													=				self.num_hidden_layers + 2






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __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
   __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													=				FunnelConfig(
       vocab_size=self.vocab_size      ,block_sizes=self.block_sizes      ,num_decoder_layers=self.num_decoder_layers      ,d_model=self.d_model      ,n_head=self.n_head      ,d_head=self.d_head      ,d_inner=self.d_inner      ,hidden_act=self.hidden_act      ,hidden_dropout=self.hidden_dropout      ,attention_dropout=self.attention_dropout      ,activation_dropout=self.activation_dropout      ,max_position_embeddings=self.max_position_embeddings      ,type_vocab_size=self.type_vocab_size      ,initializer_std=self.initializer_std      ,)

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






  def       SCREAMING_SNAKE_CASE   (   self     :  int      ,lowercase__     :  List[str]      ,lowercase__     :  Union[str, Any]      ,lowercase__     :  int      ,lowercase__     :  List[str]      ,lowercase__     :  Optional[int]      ,lowercase__     :  List[Any]      ,lowercase__     :  List[str]      ,):
   __lowercase													=				TFFunnelModel(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )

   __lowercase													=				[input_ids, input_mask]
   __lowercase													=				model(lowercase__    )

   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.d_model)    )

   __lowercase													=				False
   __lowercase													=				TFFunnelModel(config=lowercase__    )
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.d_model)    )

   __lowercase													=				False
   __lowercase													=				TFFunnelModel(config=lowercase__    )
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.d_model)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  int      ,lowercase__     :  List[Any]      ,lowercase__     :  Tuple      ,lowercase__     :  Dict      ,lowercase__     :  Any      ,lowercase__     :  Optional[Any]      ,lowercase__     :  Union[str, Any]      ,lowercase__     :  Dict      ,):
   __lowercase													=				TFFunnelBaseModel(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )

   __lowercase													=				[input_ids, input_mask]
   __lowercase													=				model(lowercase__    )

   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, 2, self.d_model)    )

   __lowercase													=				False
   __lowercase													=				TFFunnelBaseModel(config=lowercase__    )
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, 3, self.d_model)    )

   __lowercase													=				False
   __lowercase													=				TFFunnelBaseModel(config=lowercase__    )
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, 2, self.d_model)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Tuple      ,lowercase__     :  Any      ,lowercase__     :  Any      ,lowercase__     :  List[Any]      ,lowercase__     :  Optional[int]      ,lowercase__     :  Dict      ,lowercase__     :  int      ,lowercase__     :  List[str]      ,):
   __lowercase													=				TFFunnelForPreTraining(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]      ,lowercase__     :  Union[str, Any]      ,lowercase__     :  Optional[Any]      ,lowercase__     :  Dict      ,lowercase__     :  List[Any]      ,lowercase__     :  Tuple      ,lowercase__     :  Optional[Any]      ,lowercase__     :  Tuple      ,):
   __lowercase													=				TFFunnelForMaskedLM(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]      ,lowercase__     :  Tuple      ,lowercase__     :  Optional[Any]      ,lowercase__     :  List[Any]      ,lowercase__     :  List[Any]      ,lowercase__     :  str      ,lowercase__     :  Union[str, Any]      ,lowercase__     :  Tuple      ,):
   __lowercase													=				self.num_labels
   __lowercase													=				TFFunnelForSequenceClassification(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Dict      ,lowercase__     :  List[str]      ,lowercase__     :  Optional[Any]      ,lowercase__     :  List[str]      ,lowercase__     :  List[str]      ,lowercase__     :  List[str]      ,lowercase__     :  str      ,lowercase__     :  Tuple      ,):
   __lowercase													=				self.num_choices
   __lowercase													=				TFFunnelForMultipleChoice(config=lowercase__    )
   __lowercase													=				tf.tile(tf.expand_dims(lowercase__      ,1    )      ,(1, self.num_choices, 1)    )
   __lowercase													=				tf.tile(tf.expand_dims(lowercase__      ,1    )      ,(1, self.num_choices, 1)    )
   __lowercase													=				tf.tile(tf.expand_dims(lowercase__      ,1    )      ,(1, self.num_choices, 1)    )
   __lowercase													=				{
       '''input_ids''': multiple_choice_inputs_ids,
       '''attention_mask''': multiple_choice_input_mask,
       '''token_type_ids''': multiple_choice_token_type_ids,
   }
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_choices)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]      ,lowercase__     :  Optional[Any]      ,lowercase__     :  List[Any]      ,lowercase__     :  List[str]      ,lowercase__     :  List[Any]      ,lowercase__     :  Dict      ,lowercase__     :  Any      ,lowercase__     :  Union[str, Any]      ,):
   __lowercase													=				self.num_labels
   __lowercase													=				TFFunnelForTokenClassification(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(lowercase__    )
   self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.num_labels)    )






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]      ,lowercase__     :  Optional[Any]      ,lowercase__     :  Optional[int]      ,lowercase__     :  Dict      ,lowercase__     :  List[str]      ,lowercase__     :  str      ,lowercase__     :  Tuple      ,lowercase__     :  Any      ,):
   __lowercase													=				TFFunnelForQuestionAnswering(config=lowercase__    )
   __lowercase													=				{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
   __lowercase													=				model(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       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   __lowercase													=				self.prepare_config_and_inputs()
   (
       (
       __lowercase
   )						,			(
       __lowercase
   )						,			(
       __lowercase
   )						,			(
       __lowercase
   )						,			(
       __lowercase
   )						,			(
       __lowercase
   )						,			(
       __lowercase
   )						,			
   )													=				config_and_inputs
   __lowercase													=				{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
   return config, inputs_dict






@require_tf
class     lowercase_			(lowerCamelCase__       , lowerCamelCase__       , unittest.TestCase   ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE					:						int           =    (
      (
          TFFunnelModel,
          TFFunnelForMaskedLM,
          TFFunnelForPreTraining,
          TFFunnelForQuestionAnswering,
          TFFunnelForTokenClassification,
      )
      if is_tf_available()
      else ()
  )
  SCREAMING_SNAKE_CASE					:						Union[str, Any]           =    (
      {
          'feature-extraction': (TFFunnelBaseModel, TFFunnelModel),
          'fill-mask': TFFunnelForMaskedLM,
          'question-answering': TFFunnelForQuestionAnswering,
          'text-classification': TFFunnelForSequenceClassification,
          'token-classification': TFFunnelForTokenClassification,
          'zero-shot': TFFunnelForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  SCREAMING_SNAKE_CASE					:						Tuple           =    False
  SCREAMING_SNAKE_CASE					:						Any           =    False






  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   __lowercase													=				TFFunnelModelTester(self    )
   __lowercase													=				ConfigTester(self      ,config_class=lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   self.config_tester.run_common_tests()






  def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_pretraining(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_lm(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_token_classification(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_question_answering(*lowercase__    )






@require_tf
class     lowercase_			(lowerCamelCase__       , unittest.TestCase   ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE					:						List[Any]           =    (
      (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
  )
  SCREAMING_SNAKE_CASE					:						Dict           =    False
  SCREAMING_SNAKE_CASE					:						List[str]           =    False






  def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
   __lowercase													=				TFFunnelModelTester(self      ,base=lowercase__    )
   __lowercase													=				ConfigTester(self      ,config_class=lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   self.config_tester.run_common_tests()






  def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_base_model(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_sequence_classification(*lowercase__    )






  def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
   __lowercase													=				self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_multiple_choice(*lowercase__    )

