





'''simple docstring'''




import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

import diffusers
from diffusers import (
    AutoencoderKL,
    EulerDiscreteScheduler,
    StableDiffusionLatentUpscalePipeline,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.schedulers import KarrasDiffusionSchedulers
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()






def 			_lowerCAmelCase     (    __snake_case    :					Union[str, Any]     )	->	Optional[int]:
     __A		:					str						=			[tensor.shape for tensor in tensor_list]
     return all(shape == shapes[0] for shape in shapes[1:]     )


class 					SCREAMING_SNAKE_CASE       (a__   ,						a__   ,						a__   ,						unittest.TestCase				):
     lowerCAmelCase						     =			StableDiffusionLatentUpscalePipeline
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
         '''height''',
         '''width''',
         '''cross_attention_kwargs''',
         '''negative_prompt_embeds''',
         '''prompt_embeds''',
     }
     lowerCAmelCase						     =			PipelineTesterMixin.required_optional_params - {'''num_images_per_prompt'''}
     lowerCAmelCase						     =			TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
     lowerCAmelCase						     =			frozenset(
         []				)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
     lowerCAmelCase						     =			frozenset([]				)

     lowerCAmelCase						     =			True


     @property
     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[int]						=			1
          __A		:					str						=			4
          __A		:					Dict						=			(16, 16)

          __A		:					List[Any]						=			floats_tensor((batch_size, num_channels) + sizes		,      rng=random.Random(0)).to(_UpperCAmelCase)
          return image


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          torch.manual_seed(0)
          __A		:					Dict						=			UNetaDConditionModel(
              act_fn='gelu'		,      attention_head_dim=8		,      norm_num_groups=_UpperCAmelCase		,      block_out_channels=[32, 32, 64, 64]		,      time_cond_proj_dim=160		,      conv_in_kernel=1		,      conv_out_kernel=1		,      cross_attention_dim=32		,      down_block_types=(
                  'KDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
                  'KCrossAttnDownBlock2D',
              )		,      in_channels=8		,      mid_block_type=_UpperCAmelCase		,      only_cross_attention=_UpperCAmelCase		,      out_channels=5		,      resnet_time_scale_shift='scale_shift'		,      time_embedding_type='fourier'		,      timestep_post_act='gelu'		,      up_block_types=('KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KCrossAttnUpBlock2D', 'KUpBlock2D')		,      )
          __A		:					int						=			AutoencoderKL(
              block_out_channels=[32, 32, 64, 64]		,      in_channels=3		,      out_channels=3		,      down_block_types=[
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
                  'DownEncoderBlock2D',
              ]		,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D', 'UpDecoderBlock2D']		,      latent_channels=4		,      )
          __A		:					List[Any]						=			EulerDiscreteScheduler(prediction_type='sample')
          __A		:					Union[str, Any]						=			CLIPTextConfig(
              bos_token_id=0		,      eos_token_id=2		,      hidden_size=32		,      intermediate_size=37		,      layer_norm_eps=1e-0_5		,      num_attention_heads=4		,      num_hidden_layers=5		,      pad_token_id=1		,      vocab_size=1000		,      hidden_act='quick_gelu'		,      projection_dim=512		,      )
          __A		:					List[str]						=			CLIPTextModel(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip')

          __A		:					List[str]						=			{
              'unet': model.eval(),
              'vae': vae.eval(),
              'scheduler': scheduler,
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
          }

          return components


     def 				SCREAMING_SNAKE_CASE    (		self		,      _UpperCAmelCase		,      _UpperCAmelCase=0):

          '''simple docstring'''






          if str(_UpperCAmelCase).startswith('mps'):
               __A		:					Optional[Any]						=			torch.manual_seed(_UpperCAmelCase)
          else:
               __A		:					Tuple						=			torch.Generator(device=_UpperCAmelCase).manual_seed(_UpperCAmelCase)
          __A		:					List[str]						=			{
              'prompt': 'A painting of a squirrel eating a burger',
              'image': self.dummy_image.cpu(),
              'generator': generator,
              'num_inference_steps': 2,
              'output_type': 'numpy',
          }
          return inputs


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Optional[Any]						=			'cpu'

          __A		:					str						=			self.get_dummy_components()
          __A		:					Optional[Any]						=			self.pipeline_class(**_UpperCAmelCase)
          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)

          __A		:					Optional[Any]						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					List[str]						=			pipe(**_UpperCAmelCase).images
          __A		:					Union[str, Any]						=			image[0, -3:, -3:, -1]

          self.assertEqual(image.shape		,      (1, 256, 256, 3))
          __A		:					Any						=			np.array(
              [0.47222412, 0.41921633, 0.44717434, 0.46874192, 0.42588258, 0.46150726, 0.4677534, 0.45583832, 0.48579055])
          __A		:					List[Any]						=			np.abs(image_slice.flatten() - expected_slice).max()
          self.assertLessEqual(_UpperCAmelCase		,      1e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_attention_slicing_forward_pass(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_cpu_offload_forward_pass(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_inference_batch_single_identical(expected_max_diff=7e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_pt_np_pil_outputs_equivalent(expected_max_diff=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_local(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().test_save_load_optional_components(expected_max_difference=3e-3)


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Tuple						=			[
              'DDIMScheduler',
              'DDPMScheduler',
              'PNDMScheduler',
              'HeunDiscreteScheduler',
              'EulerAncestralDiscreteScheduler',
              'KDPM2DiscreteScheduler',
              'KDPM2AncestralDiscreteScheduler',
              'DPMSolverSDEScheduler',
          ]
          __A		:					int						=			self.get_dummy_components()
          __A		:					Union[str, Any]						=			self.pipeline_class(**_UpperCAmelCase)

          # make sure that PNDM does not need warm-up
          pipe.scheduler.register_to_config(skip_prk_steps=_UpperCAmelCase)

          pipe.to(_UpperCAmelCase)
          pipe.set_progress_bar_config(disable=_UpperCAmelCase)
          __A		:					int						=			self.get_dummy_inputs(_UpperCAmelCase)
          __A		:					Union[str, Any]						=			2

          __A		:					List[str]						=			[]
          for scheduler_enum in KarrasDiffusionSchedulers:
               if scheduler_enum.name in skip_schedulers:
                    # no sigma schedulers are not supported
                    # no schedulers
                    continue

               __A		:					List[str]						=			getattr(_UpperCAmelCase		,      scheduler_enum.name)
               __A		:					Optional[Any]						=			scheduler_cls.from_config(pipe.scheduler.config)
               __A		:					Any						=			pipe(**_UpperCAmelCase)[0]
               outputs.append(_UpperCAmelCase)

          assert check_same_shape(_UpperCAmelCase)




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


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					str						=			torch.manual_seed(33)

          __A		:					List[str]						=			StableDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'		,      torch_dtype=torch.floataa)
          pipe.to('cuda')

          __A		:					List[Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'a photo of an astronaut high resolution, unreal engine, ultra realistic'

          __A		:					Any						=			pipe(_UpperCAmelCase		,      generator=_UpperCAmelCase		,      output_type='latent').images

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					Optional[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/astronaut_1024.npy')
          assert np.abs((expected_image - image).mean()) < 5e-2


     def 				SCREAMING_SNAKE_CASE    (		self):

          '''simple docstring'''






          __A		:					Union[str, Any]						=			torch.manual_seed(33)

          __A		:					Union[str, Any]						=			StableDiffusionLatentUpscalePipeline.from_pretrained(
              'stabilityai/sd-x2-latent-upscaler'		,      torch_dtype=torch.floataa)
          upscaler.to('cuda')

          __A		:					Any						=			'the temple of fire by Ross Tran and Gerardo Dottori, oil on canvas'

          __A		:					Dict						=			load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_512.png')

          __A		:					int						=			upscaler(
              prompt=_UpperCAmelCase		,      image=_UpperCAmelCase		,      num_inference_steps=20		,      guidance_scale=0		,      generator=_UpperCAmelCase		,      output_type='np'		,      ).images[0]

          __A		:					List[Any]						=			load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/latent-upscaler/fire_temple_1024.npy')
          assert np.abs((expected_image - image).max()) < 5e-2

from __future__ import annotations

import unittest

from transformers import DebertaVaConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

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 (
			    TFDebertaVaForMaskedLM,
			    TFDebertaVaForQuestionAnswering,
			    TFDebertaVaForSequenceClassification,
			    TFDebertaVaForTokenClassification,
			    TFDebertaVaModel,
			)





class       _lowerCAmelCase   :




				def __init__(   self							,							_UpperCamelCase							,							_UpperCamelCase=13							,							_UpperCamelCase=7							,							_UpperCamelCase=True							,							_UpperCamelCase=True							,							_UpperCamelCase=True							,							_UpperCamelCase=True							,							_UpperCamelCase=99							,							_UpperCamelCase=32							,							_UpperCamelCase=2							,							_UpperCamelCase=4							,							_UpperCamelCase=37							,							_UpperCamelCase="gelu"							,							_UpperCamelCase=0.1							,							_UpperCamelCase=0.1							,							_UpperCamelCase=512							,							_UpperCamelCase=16							,							_UpperCamelCase=2							,							_UpperCamelCase=0.02							,							_UpperCamelCase=False							,							_UpperCamelCase=True							,							_UpperCamelCase="None"							,							_UpperCamelCase=3							,							_UpperCamelCase=4							,							_UpperCamelCase=None							,							)							-> Tuple:
							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_         =      hidden_size
							lowerCAmelCase_         =      num_hidden_layers
							lowerCAmelCase_         =      num_attention_heads
							lowerCAmelCase_         =      intermediate_size
							lowerCAmelCase_         =      hidden_act
							lowerCAmelCase_         =      hidden_dropout_prob
							lowerCAmelCase_         =      attention_probs_dropout_prob
							lowerCAmelCase_         =      max_position_embeddings
							lowerCAmelCase_         =      type_vocab_size
							lowerCAmelCase_         =      type_sequence_label_size
							lowerCAmelCase_         =      initializer_range
							lowerCAmelCase_         =      num_labels
							lowerCAmelCase_         =      num_choices
							lowerCAmelCase_         =      relative_attention
							lowerCAmelCase_         =      position_biased_input
							lowerCAmelCase_         =      pos_att_type
							lowerCAmelCase_         =      scope




				def 	__a		(   self	)							-> List[str]:
							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_         =      DebertaVaConfig(
							    vocab_size=self.vocab_size							,							hidden_size=self.hidden_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							,							relative_attention=self.relative_attention							,							position_biased_input=self.position_biased_input							,							initializer_range=self.initializer_range							,							return_dict=_UpperCamelCase							,							)

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




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> Dict:
							lowerCAmelCase_         =      TFDebertaVaModel(config=_UpperCamelCase	)
							lowerCAmelCase_         =      {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}

							lowerCAmelCase_         =      [input_ids, input_mask]
							lowerCAmelCase_         =      model(_UpperCamelCase	)

							lowerCAmelCase_         =      model(_UpperCamelCase	)

							self.parent.assertEqual(result.last_hidden_state.shape							,							(self.batch_size, self.seq_length, self.hidden_size)	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> Any:
							lowerCAmelCase_         =      TFDebertaVaForMaskedLM(config=_UpperCamelCase	)
							lowerCAmelCase_         =      {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							lowerCAmelCase_         =      model(_UpperCamelCase	)
							self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.vocab_size)	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> str:
							lowerCAmelCase_         =      self.num_labels
							lowerCAmelCase_         =      TFDebertaVaForSequenceClassification(config=_UpperCamelCase	)
							lowerCAmelCase_         =      {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}

							lowerCAmelCase_         =      model(_UpperCamelCase	)
							self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.num_labels)	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> int:
							lowerCAmelCase_         =      self.num_labels
							lowerCAmelCase_         =      TFDebertaVaForTokenClassification(config=_UpperCamelCase	)
							lowerCAmelCase_         =      {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}
							lowerCAmelCase_         =      model(_UpperCamelCase	)
							self.parent.assertEqual(result.logits.shape							,							(self.batch_size, self.seq_length, self.num_labels)	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> Dict:
							lowerCAmelCase_         =      TFDebertaVaForQuestionAnswering(config=_UpperCamelCase	)
							lowerCAmelCase_         =      {
							    "input_ids": input_ids,
							    "attention_mask": input_mask,
							    "token_type_ids": token_type_ids,
							}

							lowerCAmelCase_         =      model(_UpperCamelCase	)
							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 	__a		(   self	)							-> Tuple:
							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       _lowerCAmelCase   (      __a   , __a   , unittest.TestCase			):
				_lowercase     						=(
				    (
				        TFDebertaVaModel,
				        TFDebertaVaForMaskedLM,
				        TFDebertaVaForQuestionAnswering,
				        TFDebertaVaForSequenceClassification,
				        TFDebertaVaForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				_lowercase     						=(
				    {
				        '''feature-extraction''': TFDebertaVaModel,
				        '''fill-mask''': TFDebertaVaForMaskedLM,
				        '''question-answering''': TFDebertaVaForQuestionAnswering,
				        '''text-classification''': TFDebertaVaForSequenceClassification,
				        '''token-classification''': TFDebertaVaForTokenClassification,
				        '''zero-shot''': TFDebertaVaForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)

				_lowercase     						=False
				_lowercase     						=False




				def 	__a		(   self	)							-> Optional[int]:
							lowerCAmelCase_         =      TFDebertaVaModelTester(self	)
							lowerCAmelCase_         =      ConfigTester(self							,							config_class=_UpperCamelCase							,							hidden_size=37	)




				def 	__a		(   self	)							-> str:
							self.config_tester.run_common_tests()




				def 	__a		(   self	)							-> int:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCamelCase	)




				def 	__a		(   self	)							-> List[Any]:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase	)




				def 	__a		(   self	)							-> List[str]:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_UpperCamelCase	)




				def 	__a		(   self	)							-> List[Any]:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_UpperCamelCase	)




				def 	__a		(   self	)							-> int:
							lowerCAmelCase_         =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_UpperCamelCase	)




				@slow
				def 	__a		(   self	)							-> Union[str, Any]:
							lowerCAmelCase_         =      TFDebertaVaModel.from_pretrained("kamalkraj/deberta-v2-xlarge"	)
							self.assertIsNotNone(_UpperCamelCase	)





@require_tf
class       _lowerCAmelCase   (      unittest.TestCase			):




				@unittest.skip(reason="Model not available yet"	)
				def 	__a		(   self	)							-> List[str]:
							pass




				@slow
				def 	__a		(   self	)							-> Dict:
							lowerCAmelCase_         =      TFDebertaVaModel.from_pretrained("kamalkraj/deberta-v2-xlarge"	)
							lowerCAmelCase_         =      tf.constant([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]]	)
							lowerCAmelCase_         =      tf.constant([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]	)
							lowerCAmelCase_         =      model(_UpperCamelCase							,							attention_mask=_UpperCamelCase	)[0]

							lowerCAmelCase_         =      tf.constant(
							    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]	)
							tf.debugging.assert_near(output[:, 1:4, 1:4]							,							_UpperCamelCase							,							atol=1e-4	)



