

import unittest

from transformers import DebertaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

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


if is_torch_available():
					import torch

					from transformers import (
					    DebertaForMaskedLM,
					    DebertaForQuestionAnswering,
					    DebertaForSequenceClassification,
					    DebertaForTokenClassification,
					    DebertaModel,
					)
					from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST





class  __UpperCAmelCase					(	A_						):



			def __init__(							self							:					str,		__A							:					Tuple,		__A							:					int=1_3,		__A							:					Optional[Any]=7,		__A							:					Optional[int]=True,		__A							:					List[Any]=True,		__A							:					Optional[Any]=True,		__A							:					str=True,		__A							:					List[str]=9_9,		__A							:					str=3_2,		__A							:					List[Any]=5,		__A							:					List[Any]=4,		__A							:					Dict=3_7,		__A							:					Union[str, Any]="gelu",		__A							:					Tuple=0.1,		__A							:					Any=0.1,		__A							:					Optional[int]=5_1_2,		__A							:					Union[str, Any]=1_6,		__A							:					Any=2,		__A							:					Dict=0.0_2,		__A							:					Any=False,		__A							:					Union[str, Any]=True,		__A							:					List[Any]="None",		__A							:					Any=3,		__A							:					Optional[int]=4,		__A							:					List[Any]=None,		):
					UpperCAmelCase	:							Union[str, Any]						=			parent
					UpperCAmelCase	:							Optional[Any]						=			batch_size
					UpperCAmelCase	:							str						=			seq_length
					UpperCAmelCase	:							Union[str, Any]						=			is_training
					UpperCAmelCase	:							Any						=			use_input_mask
					UpperCAmelCase	:							int						=			use_token_type_ids
					UpperCAmelCase	:							Union[str, Any]						=			use_labels
					UpperCAmelCase	:							Union[str, Any]						=			vocab_size
					UpperCAmelCase	:							Union[str, Any]						=			hidden_size
					UpperCAmelCase	:							Any						=			num_hidden_layers
					UpperCAmelCase	:							Dict						=			num_attention_heads
					UpperCAmelCase	:							Tuple						=			intermediate_size
					UpperCAmelCase	:							Optional[Any]						=			hidden_act
					UpperCAmelCase	:							Dict						=			hidden_dropout_prob
					UpperCAmelCase	:							List[Any]						=			attention_probs_dropout_prob
					UpperCAmelCase	:							Union[str, Any]						=			max_position_embeddings
					UpperCAmelCase	:							List[Any]						=			type_vocab_size
					UpperCAmelCase	:							int						=			type_sequence_label_size
					UpperCAmelCase	:							List[Any]						=			initializer_range
					UpperCAmelCase	:							Union[str, Any]						=			num_labels
					UpperCAmelCase	:							List[str]						=			num_choices
					UpperCAmelCase	:							Optional[Any]						=			relative_attention
					UpperCAmelCase	:							List[Any]						=			position_biased_input
					UpperCAmelCase	:							Tuple						=			pos_att_type
					UpperCAmelCase	:							List[Any]						=			scope



			def 	__magic_name__   (							self							:					Optional[int]						):
					UpperCAmelCase	:							Any						=			ids_tensor([self.batch_size, self.seq_length],		self.vocab_size						)

					UpperCAmelCase	:							Union[str, Any]						=			None
					if self.use_input_mask:
							UpperCAmelCase	:							Union[str, Any]						=			ids_tensor([self.batch_size, self.seq_length],		vocab_size=2						)

					UpperCAmelCase	:							List[Any]						=			None
					if self.use_token_type_ids:
							UpperCAmelCase	:							Union[str, Any]						=			ids_tensor([self.batch_size, self.seq_length],		self.type_vocab_size						)

					UpperCAmelCase	:							int						=			None
					UpperCAmelCase	:							Tuple						=			None
					UpperCAmelCase	:							Optional[Any]						=			None
					if self.use_labels:
							UpperCAmelCase	:							int						=			ids_tensor([self.batch_size],		self.type_sequence_label_size						)
							UpperCAmelCase	:							Tuple						=			ids_tensor([self.batch_size, self.seq_length],		self.num_labels						)
							UpperCAmelCase	:							Dict						=			ids_tensor([self.batch_size],		self.num_choices						)

					UpperCAmelCase	:							List[str]						=			self.get_config()

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



			def 	__magic_name__   (							self							:					Dict						):
					return DebertaConfig(
					    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,		initializer_range=self.initializer_range,		relative_attention=self.relative_attention,		position_biased_input=self.position_biased_input,		pos_att_type=self.pos_att_type,		)



			def 	__magic_name__   (							self							:					Union[str, Any]						):
					UpperCAmelCase	:							Tuple						=			self.get_config()
					UpperCAmelCase	:							Tuple						=			3_0_0
					return config



			def 	__magic_name__   (							self							:					int,		__A							:					int						):
					self.parent.assertListEqual(list(result.loss.size()						),		[]						)



			def 	__magic_name__   (							self							:					List[str],		__A							:					Dict,		__A							:					List[str],		__A							:					Optional[Any],		__A							:					Tuple,		__A							:					Tuple,		__A							:					Optional[int],		__A							:					Tuple						):
					UpperCAmelCase	:							int						=			DebertaModel(config=_lowerCamelCase						)
					model.to(_lowerCamelCase						)
					model.eval()
					UpperCAmelCase	:							Optional[Any]						=			model(_lowerCamelCase,		attention_mask=_lowerCamelCase,		token_type_ids=_lowerCamelCase						)[0]
					UpperCAmelCase	:							Tuple						=			model(_lowerCamelCase,		token_type_ids=_lowerCamelCase						)[0]
					UpperCAmelCase	:							Optional[Any]						=			model(_lowerCamelCase						)[0]

					self.parent.assertListEqual(list(sequence_output.size()						),		[self.batch_size, self.seq_length, self.hidden_size]						)



			def 	__magic_name__   (							self							:					str,		__A							:					List[str],		__A							:					str,		__A							:					Dict,		__A							:					Tuple,		__A							:					Tuple,		__A							:					Optional[int],		__A							:					int						):
					UpperCAmelCase	:							Optional[int]						=			DebertaForMaskedLM(config=_lowerCamelCase						)
					model.to(_lowerCamelCase						)
					model.eval()
					UpperCAmelCase	:							str						=			model(_lowerCamelCase,		attention_mask=_lowerCamelCase,		token_type_ids=_lowerCamelCase,		labels=_lowerCamelCase						)

					self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.seq_length, self.vocab_size)						)



			def 	__magic_name__   (							self							:					Tuple,		__A							:					Dict,		__A							:					int,		__A							:					Any,		__A							:					List[Any],		__A							:					List[Any],		__A							:					List[Any],		__A							:					int						):
					UpperCAmelCase	:							int						=			self.num_labels
					UpperCAmelCase	:							Dict						=			DebertaForSequenceClassification(_lowerCamelCase						)
					model.to(_lowerCamelCase						)
					model.eval()
					UpperCAmelCase	:							List[Any]						=			model(_lowerCamelCase,		attention_mask=_lowerCamelCase,		token_type_ids=_lowerCamelCase,		labels=_lowerCamelCase						)
					self.parent.assertListEqual(list(result.logits.size()						),		[self.batch_size, self.num_labels]						)
					self.check_loss_output(_lowerCamelCase						)



			def 	__magic_name__   (							self							:					Dict,		__A							:					Dict,		__A							:					Optional[int],		__A							:					Any,		__A							:					Optional[Any],		__A							:					List[Any],		__A							:					str,		__A							:					Optional[int]						):
					UpperCAmelCase	:							Dict						=			self.num_labels
					UpperCAmelCase	:							Dict						=			DebertaForTokenClassification(config=_lowerCamelCase						)
					model.to(_lowerCamelCase						)
					model.eval()
					UpperCAmelCase	:							Union[str, Any]						=			model(_lowerCamelCase,		attention_mask=_lowerCamelCase,		token_type_ids=_lowerCamelCase,		labels=_lowerCamelCase						)
					self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.seq_length, self.num_labels)						)



			def 	__magic_name__   (							self							:					Tuple,		__A							:					int,		__A							:					List[Any],		__A							:					int,		__A							:					str,		__A							:					Tuple,		__A							:					Optional[int],		__A							:					str						):
					UpperCAmelCase	:							str						=			DebertaForQuestionAnswering(config=_lowerCamelCase						)
					model.to(_lowerCamelCase						)
					model.eval()
					UpperCAmelCase	:							List[str]						=			model(
					    _lowerCamelCase,		attention_mask=_lowerCamelCase,		token_type_ids=_lowerCamelCase,		start_positions=_lowerCamelCase,		end_positions=_lowerCamelCase,		)
					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 	__magic_name__   (							self							:					Tuple						):
					UpperCAmelCase	:							Union[str, Any]						=			self.prepare_config_and_inputs()
					(
					    (
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						(
					    UpperCAmelCase 
					)			,						 
					)	:							Dict						=			config_and_inputs
					UpperCAmelCase	:							str						=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
					return config, inputs_dict






@require_torch
class  __UpperCAmelCase					(	A_      ,  A_      ,  unittest.TestCase						):
			UpperCamelCase       					=					(
			    (
			        DebertaModel,
			        DebertaForMaskedLM,
			        DebertaForSequenceClassification,
			        DebertaForTokenClassification,
			        DebertaForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			UpperCamelCase       					=					(
			    {
			        """feature-extraction""": DebertaModel,
			        """fill-mask""": DebertaForMaskedLM,
			        """question-answering""": DebertaForQuestionAnswering,
			        """text-classification""": DebertaForSequenceClassification,
			        """token-classification""": DebertaForTokenClassification,
			        """zero-shot""": DebertaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)

			UpperCamelCase       					=					True
			UpperCamelCase       					=					False
			UpperCamelCase       					=					False
			UpperCamelCase       					=					False
			UpperCamelCase       					=					False



			def 	__magic_name__   (							self							:					Tuple						):
					UpperCAmelCase	:							Any						=			DebertaModelTester(self						)
					UpperCAmelCase	:							Union[str, Any]						=			ConfigTester(self,		config_class=_lowerCamelCase,		hidden_size=3_7						)



			def 	__magic_name__   (							self							:					Optional[int]						):
					self.config_tester.run_common_tests()



			def 	__magic_name__   (							self							:					Union[str, Any]						):
					UpperCAmelCase	:							str						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_deberta_model(*_lowerCamelCase						)



			def 	__magic_name__   (							self							:					Tuple						):
					UpperCAmelCase	:							Any						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_deberta_for_sequence_classification(*_lowerCamelCase						)



			def 	__magic_name__   (							self							:					Dict						):
					UpperCAmelCase	:							str						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_deberta_for_masked_lm(*_lowerCamelCase						)



			def 	__magic_name__   (							self							:					Optional[Any]						):
					UpperCAmelCase	:							Optional[int]						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_deberta_for_question_answering(*_lowerCamelCase						)



			def 	__magic_name__   (							self							:					str						):
					UpperCAmelCase	:							List[str]						=			self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_deberta_for_token_classification(*_lowerCamelCase						)





			@slow
			def 	__magic_name__   (							self							:					Union[str, Any]						):
					for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase	:							Tuple						=			DebertaModel.from_pretrained(_lowerCamelCase						)
							self.assertIsNotNone(_lowerCamelCase						)






@require_torch
@require_sentencepiece
@require_tokenizers
class  __UpperCAmelCase					(	unittest.TestCase						):



			@unittest.skip(reason='''Model not available yet'''						)
			def 	__magic_name__   (							self							:					List[Any]						):
					pass





			@slow
			def 	__magic_name__   (							self							:					int						):
					UpperCAmelCase	:							Dict						=			DebertaModel.from_pretrained('''microsoft/deberta-base'''						)

					UpperCAmelCase	:							str						=			torch.tensor([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]						)
					UpperCAmelCase	:							int						=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]						)
					with torch.no_grad():
							UpperCAmelCase	:							List[Any]						=			model(_lowerCamelCase,		attention_mask=_lowerCamelCase						)[0]
					# compare the actual values for a slice.
					UpperCAmelCase	:							List[str]						=			torch.tensor(
					    [[[-0.5_9_8_6, -0.8_0_5_5, -0.8_4_6_2], [1.4_4_8_4, -0.9_3_4_8, -0.8_0_5_9], [0.3_1_2_3, 0.0_0_3_2, -1.4_1_3_1]]]						)
					self.assertTrue(torch.allclose(output[:, 1:4, 1:4],		_lowerCamelCase,		atol=1E-4						),		F'''{output[:, 1:4, 1:4]}'''						)








import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference





class  __UpperCAmelCase					(	lowerCamelCase__      ,  unittest.TestCase						):
   UpperCamelCase       					=					ShapEImgaImgPipeline
   UpperCamelCase       					=					["""image"""]
   UpperCamelCase       					=					["""image"""]
   UpperCamelCase       					=					[
       """num_images_per_prompt""",
       """num_inference_steps""",
       """generator""",
       """latents""",
       """guidance_scale""",
       """frame_size""",
       """output_type""",
       """return_dict""",
   ]
   UpperCamelCase       					=					False



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



   @property
   def 	__magic_name__   (							self							:					Optional[int]						):
     return 3_2



   @property
   def 	__magic_name__   (							self							:					Union[str, Any]						):
     return self.time_input_dim * 4



   @property
   def 	__magic_name__   (							self							:					Any						):
     return 8



   @property
   def 	__magic_name__   (							self							:					List[str]						):
     torch.manual_seed(0						)
     UpperCAmelCase	:							str						=			CLIPVisionConfig(
         hidden_size=self.text_embedder_hidden_size,		image_size=6_4,		projection_dim=self.text_embedder_hidden_size,		intermediate_size=3_7,		num_attention_heads=4,		num_channels=3,		num_hidden_layers=5,		patch_size=1,		)

     UpperCAmelCase	:							Any						=			CLIPVisionModel(__A						)
     return model



   @property
   def 	__magic_name__   (							self							:					int						):
     UpperCAmelCase	:							Optional[int]						=			CLIPImageProcessor(
         crop_size=2_2_4,		do_center_crop=__A,		do_normalize=__A,		do_resize=__A,		image_mean=[0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],		image_std=[0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],		resample=3,		size=2_2_4,		)

     return image_processor



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

     UpperCAmelCase	:							Any						=			{
         '''num_attention_heads''': 2,
         '''attention_head_dim''': 1_6,
         '''embedding_dim''': self.time_input_dim,
         '''num_embeddings''': 3_2,
         '''embedding_proj_dim''': self.text_embedder_hidden_size,
         '''time_embed_dim''': self.time_embed_dim,
         '''num_layers''': 1,
         '''clip_embed_dim''': self.time_input_dim * 2,
         '''additional_embeddings''': 0,
         '''time_embed_act_fn''': '''gelu''',
         '''norm_in_type''': '''layer''',
         '''embedding_proj_norm_type''': '''layer''',
         '''encoder_hid_proj_type''': None,
         '''added_emb_type''': None,
     }

     UpperCAmelCase	:							List[Any]						=			PriorTransformer(**__A						)
     return model



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

     UpperCAmelCase	:							List[Any]						=			{
         '''param_shapes''': (
             (self.renderer_dim, 9_3),
             (self.renderer_dim, 8),
             (self.renderer_dim, 8),
             (self.renderer_dim, 8),
         ),
         '''d_latent''': self.time_input_dim,
         '''d_hidden''': self.renderer_dim,
         '''n_output''': 1_2,
         '''background''': (
             0.1,
             0.1,
             0.1,
         ),
     }
     UpperCAmelCase	:							List[str]						=			ShapERenderer(**__A						)
     return model



   def 	__magic_name__   (							self							:					List[Any]						):
     UpperCAmelCase	:							str						=			self.dummy_prior
     UpperCAmelCase	:							List[str]						=			self.dummy_image_encoder
     UpperCAmelCase	:							List[Any]						=			self.dummy_image_processor
     UpperCAmelCase	:							Dict						=			self.dummy_renderer

     UpperCAmelCase	:							int						=			HeunDiscreteScheduler(
         beta_schedule='''exp''',		num_train_timesteps=1_0_2_4,		prediction_type='''sample''',		use_karras_sigmas=__A,		clip_sample=__A,		clip_sample_range=1.0,		)
     UpperCAmelCase	:							List[str]						=			{
         '''prior''': prior,
         '''image_encoder''': image_encoder,
         '''image_processor''': image_processor,
         '''renderer''': renderer,
         '''scheduler''': scheduler,
     }

     return components



   def 	__magic_name__   (							self							:					List[Any],		__A							:					Dict,		__A							:					List[Any]=0						):
     UpperCAmelCase	:							int						=			floats_tensor((1, 3, 6_4, 6_4),		rng=random.Random(__A						)						).to(__A						)

     if str(__A						).startswith('''mps'''						):
       UpperCAmelCase	:							List[str]						=			torch.manual_seed(__A						)
     else:
       UpperCAmelCase	:							Optional[Any]						=			torch.Generator(device=__A						).manual_seed(__A						)
     UpperCAmelCase	:							Dict						=			{
         '''image''': input_image,
         '''generator''': generator,
         '''num_inference_steps''': 1,
         '''frame_size''': 3_2,
         '''output_type''': '''np''',
     }
     return inputs



   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							Dict						=			'''cpu'''

     UpperCAmelCase	:							Any						=			self.get_dummy_components()

     UpperCAmelCase	:							Tuple						=			self.pipeline_class(**__A						)
     UpperCAmelCase	:							Dict						=			pipe.to(__A						)

     pipe.set_progress_bar_config(disable=__A						)

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

     assert image.shape == (2_0, 3_2, 3_2, 3)

     UpperCAmelCase	:							Optional[int]						=			np.array(
         [
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
             0.0_0_0_3_9_2_1_6,
         ]						)

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



   def 	__magic_name__   (							self							:					Dict						):
     # NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
     self._test_inference_batch_consistent(batch_sizes=[1, 2]						)



   def 	__magic_name__   (							self							:					str						):
     UpperCAmelCase	:							Tuple						=			torch_device == '''cpu'''
     UpperCAmelCase	:							List[Any]						=			True
     self._test_inference_batch_single_identical(
         batch_size=2,		test_max_difference=__A,		relax_max_difference=__A,		)





   def 	__magic_name__   (							self							:					Dict						):
     UpperCAmelCase	:							Dict						=			self.get_dummy_components()
     UpperCAmelCase	:							Union[str, Any]						=			self.pipeline_class(**__A						)
     UpperCAmelCase	:							List[str]						=			pipe.to(__A						)
     pipe.set_progress_bar_config(disable=__A						)

     UpperCAmelCase	:							Any						=			1
     UpperCAmelCase	:							Any						=			2

     UpperCAmelCase	:							Optional[int]						=			self.get_dummy_inputs(__A						)

     for key in inputs.keys():
       if key in self.batch_params:
         UpperCAmelCase	:							Any						=			batch_size * [inputs[key]]

     UpperCAmelCase	:							int						=			pipe(**__A,		num_images_per_prompt=__A						)[0]

     assert images.shape[0] == batch_size * num_images_per_prompt






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



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





   def 	__magic_name__   (							self							:					Tuple						):
     UpperCAmelCase	:							List[str]						=			load_image(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/shap_e/corgi.png'''						)
     UpperCAmelCase	:							Dict						=			load_numpy(
         '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
         '''/shap_e/test_shap_e_img2img_out.npy'''						)
     UpperCAmelCase	:							Union[str, Any]						=			ShapEImgaImgPipeline.from_pretrained('''openai/shap-e-img2img'''						)
     UpperCAmelCase	:							int						=			pipe.to(__A						)
     pipe.set_progress_bar_config(disable=__A						)

     UpperCAmelCase	:							Dict						=			torch.Generator(device=__A						).manual_seed(0						)

     UpperCAmelCase	:							List[str]						=			pipe(
         __A,		generator=__A,		guidance_scale=3.0,		num_inference_steps=6_4,		frame_size=6_4,		output_type='''np''',		).images[0]

     assert images.shape == (2_0, 6_4, 6_4, 3)

     assert_mean_pixel_difference(__A,		__A						)





