




"""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 					__magic_name__							:






				'''simple docstring'''





				def __init__( self	,				_a	,				_a=13	,				_a=7	,				_a=True	,				_a=True	,				_a=True	,				_a=True	,				_a=99	,				_a=[1, 1, 2]	,				_a=1	,				_a=32	,				_a=4	,				_a=8	,				_a=37	,				_a="gelu_new"	,				_a=0.1	,				_a=0.1	,				_a=0.0	,				_a=512	,				_a=3	,				_a=0.02	,				_a=3	,				_a=4	,				_a=None	,				_a=False	,				):





							"""simple docstring"""
							lowerCamelCase       =      parent
							lowerCamelCase       =      batch_size
							lowerCamelCase       =      seq_length
							lowerCamelCase       =      is_training
							lowerCamelCase       =      use_input_mask
							lowerCamelCase       =      use_token_type_ids
							lowerCamelCase       =      use_labels
							lowerCamelCase       =      vocab_size
							lowerCamelCase       =      block_sizes
							lowerCamelCase       =      num_decoder_layers
							lowerCamelCase       =      d_model
							lowerCamelCase       =      n_head
							lowerCamelCase       =      d_head
							lowerCamelCase       =      d_inner
							lowerCamelCase       =      hidden_act
							lowerCamelCase       =      hidden_dropout
							lowerCamelCase       =      attention_dropout
							lowerCamelCase       =      activation_dropout
							lowerCamelCase       =      max_position_embeddings
							lowerCamelCase       =      type_vocab_size
							lowerCamelCase       =      2
							lowerCamelCase       =      num_labels
							lowerCamelCase       =      num_choices
							lowerCamelCase       =      scope
							lowerCamelCase       =      initializer_std

							# Used in the tests to check the size of the first attention layer
							lowerCamelCase       =      n_head
							# Used in the tests to check the size of the first hidden state
							lowerCamelCase       =      self.d_model
							# Used in the tests to check the number of output hidden states/attentions
							lowerCamelCase       =      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:
										lowerCamelCase       =      self.num_hidden_layers + 2





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      ids_tensor([self.batch_size, self.seq_length]	,				self.vocab_size				)

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

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

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

							lowerCamelCase       =      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      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelModel(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)

							lowerCamelCase       =      [input_ids, input_mask]
							lowerCamelCase       =      model(snake_case_				)

							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.last_hidden_state.shape	,				(self.batch_size, self.seq_length, self.d_model)				)

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

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





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelBaseModel(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)

							lowerCamelCase       =      [input_ids, input_mask]
							lowerCamelCase       =      model(snake_case_				)

							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.last_hidden_state.shape	,				(self.batch_size, 2, self.d_model)				)

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

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





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelForPreTraining(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.seq_length)				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelForMaskedLM(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.seq_length, self.vocab_size)				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      self.num_labels
							lowerCamelCase       =      TFFunnelForSequenceClassification(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_labels)				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      self.num_choices
							lowerCamelCase       =      TFFunnelForMultipleChoice(config=snake_case_				)
							lowerCamelCase       =      tf.tile(tf.expand_dims(snake_case_	,				1				)	,				(1, self.num_choices, 1)				)
							lowerCamelCase       =      tf.tile(tf.expand_dims(snake_case_	,				1				)	,				(1, self.num_choices, 1)				)
							lowerCamelCase       =      tf.tile(tf.expand_dims(snake_case_	,				1				)	,				(1, self.num_choices, 1)				)
							lowerCamelCase       =      {
							    """input_ids""": multiple_choice_inputs_ids,
							    """attention_mask""": multiple_choice_input_mask,
							    """token_type_ids""": multiple_choice_token_type_ids,
							}
							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_choices)				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      self.num_labels
							lowerCamelCase       =      TFFunnelForTokenClassification(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)
							self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.seq_length, self.num_labels)				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				_a	,				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelForQuestionAnswering(config=snake_case_				)
							lowerCamelCase       =      {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
							lowerCamelCase       =      model(snake_case_				)
							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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.prepare_config_and_inputs()
							(
							    (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     (
							    lowerCamelCase						
							)   ,     						
							)       =      config_and_inputs
							lowerCamelCase       =      {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
							return config, inputs_dict






@require_tf
class 					__magic_name__							( _a		,      _a		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		(
				    (
				        TFFunnelModel,
				        TFFunnelForMaskedLM,
				        TFFunnelForPreTraining,
				        TFFunnelForQuestionAnswering,
				        TFFunnelForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				__UpperCamelCase    						=		(
				    {
				        """feature-extraction""": (TFFunnelBaseModel, TFFunnelModel),
				        """fill-mask""": TFFunnelForMaskedLM,
				        """question-answering""": TFFunnelForQuestionAnswering,
				        """text-classification""": TFFunnelForSequenceClassification,
				        """token-classification""": TFFunnelForTokenClassification,
				        """zero-shot""": TFFunnelForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelModelTester(self				)
							lowerCamelCase       =      ConfigTester(self	,				config_class=snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*snake_case_				)






@require_tf
class 					__magic_name__							( _a		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		(
				    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
				)
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      TFFunnelModelTester(self	,				base=snake_case_				)
							lowerCamelCase       =      ConfigTester(self	,				config_class=snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_base_model(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*snake_case_				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*snake_case_				)









"""simple docstring"""




import unittest

import numpy as np
import torch

from diffusers import ScoreSdeVePipeline, ScoreSdeVeScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()






class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				@property
				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							torch.manual_seed(0				)
							lowerCamelCase       =      UNetaDModel(
							    block_out_channels=(32, 64)	,				layers_per_block=2	,				sample_size=32	,				in_channels=3	,				out_channels=3	,				down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")	,				up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")	,				)
							return model





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.dummy_uncond_unet
							lowerCamelCase       =      ScoreSdeVeScheduler()

							lowerCamelCase       =      ScoreSdeVePipeline(unet=_a	,				scheduler=_a				)
							sde_ve.to(_a				)
							sde_ve.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      torch.manual_seed(0				)
							lowerCamelCase       =      sde_ve(num_inference_steps=2	,				output_type="""numpy"""	,				generator=_a				).images

							lowerCamelCase       =      torch.manual_seed(0				)
							lowerCamelCase       =      sde_ve(num_inference_steps=2	,				output_type="""numpy"""	,				generator=_a	,				return_dict=_a				)[
							    0
							]

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

							assert image.shape == (1, 32, 32, 3)
							lowerCamelCase       =      np.array([0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.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






@slow
@require_torch
class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      """google/ncsnpp-church-256"""
							lowerCamelCase       =      UNetaDModel.from_pretrained(_a				)

							lowerCamelCase       =      ScoreSdeVeScheduler.from_pretrained(_a				)

							lowerCamelCase       =      ScoreSdeVePipeline(unet=_a	,				scheduler=_a				)
							sde_ve.to(_a				)
							sde_ve.set_progress_bar_config(disable=_a				)

							lowerCamelCase       =      torch.manual_seed(0				)
							lowerCamelCase       =      sde_ve(num_inference_steps=10	,				output_type="""numpy"""	,				generator=_a				).images

							lowerCamelCase       =      image[0, -3:, -3:, -1]

							assert image.shape == (1, 256, 256, 3)

							lowerCamelCase       =      np.array([0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0]				)

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



