




"""simple docstring"""

import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableDiffusionUpscalePipeline, UNetaDConditionModel
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


enable_full_determinism()

class        lowercase      (    unittest.TestCase):







				def 					a_  (							self   :					Optional[Any]       ):



					"""simple docstring"""

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







				@property
				def 					a_  (							self   :					Tuple       ):



					"""simple docstring"""

					A_  :				str	   =		1
					A_  :				List[str]	   =		3
					A_  :				int	   =		(32, 32)

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







				@property
				def 					a_  (							self   :					Optional[Any]       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				List[str]	   =		UNetaDConditionModel(
					    block_out_channels=(32, 32, 64)      ,     layers_per_block=2      ,     sample_size=32      ,     in_channels=7      ,     out_channels=4      ,     down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''', '''CrossAttnDownBlock2D''')      ,     up_block_types=('''CrossAttnUpBlock2D''', '''CrossAttnUpBlock2D''', '''UpBlock2D''')      ,     cross_attention_dim=32      ,     attention_head_dim=8      ,     use_linear_projection=_lowerCamelCase      ,     only_cross_attention=(True, True, False)      ,     num_class_embeds=1_00      ,     )
					return model







				@property
				def 					a_  (							self   :					Union[str, Any]       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				List[Any]	   =		AutoencoderKL(
					    block_out_channels=[32, 32, 64]      ,     in_channels=3      ,     out_channels=3      ,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''', '''DownEncoderBlock2D''']      ,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''', '''UpDecoderBlock2D''']      ,     latent_channels=4      ,     )
					return model







				@property
				def 					a_  (							self   :					Dict       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				List[str]	   =		CLIPTextConfig(
					    bos_token_id=0      ,     eos_token_id=2      ,     hidden_size=32      ,     intermediate_size=37      ,     layer_norm_eps=1E-05      ,     num_attention_heads=4      ,     num_hidden_layers=5      ,     pad_token_id=1      ,     vocab_size=10_00      ,     hidden_act='''gelu'''      ,     projection_dim=5_12      ,     )
					return CLIPTextModel(_lowerCamelCase       )







				def 					a_  (							self   :					Optional[Any]       ):



					"""simple docstring"""

					A_  :				Union[str, Any]	   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
					A_  :				Optional[Any]	   =		self.dummy_cond_unet_upscale
					A_  :				Optional[int]	   =		DDPMScheduler()
					A_  :				Union[str, Any]	   =		DDIMScheduler(prediction_type='''v_prediction'''       )
					A_  :				Dict	   =		self.dummy_vae
					A_  :				int	   =		self.dummy_text_encoder
					A_  :				int	   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

					A_  :				Union[str, Any]	   =		self.dummy_image.cpu().permute(0      ,     2      ,     3      ,     1       )[0]
					A_  :				str	   =		Image.fromarray(np.uinta(_lowerCamelCase       )       ).convert('''RGB'''       ).resize((64, 64)       )

					# make sure here that pndm scheduler skips prk
					A_  :				Tuple	   =		StableDiffusionUpscalePipeline(
					    unet=_lowerCamelCase      ,     low_res_scheduler=_lowerCamelCase      ,     scheduler=_lowerCamelCase      ,     vae=_lowerCamelCase      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase      ,     max_noise_level=3_50      ,     )
					A_  :				List[str]	   =		sd_pipe.to(_lowerCamelCase       )
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase       )

					A_  :				Optional[int]	   =		'''A painting of a squirrel eating a burger'''
					A_  :				int	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				int	   =		sd_pipe(
					    [prompt]      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     guidance_scale=6.0      ,     noise_level=20      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )

					A_  :				Dict	   =		output.images

					A_  :				List[str]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				List[Any]	   =		sd_pipe(
					    [prompt]      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     guidance_scale=6.0      ,     noise_level=20      ,     num_inference_steps=2      ,     output_type='''np'''      ,     return_dict=_lowerCamelCase      ,     )[0]

					A_  :				List[str]	   =		image[0, -3:, -3:, -1]
					A_  :				List[str]	   =		image_from_tuple[0, -3:, -3:, -1]

					A_  :				int	   =		low_res_image.size[0] * 4
					assert image.shape == (1, expected_height_width, expected_height_width, 3)
					A_  :				int	   =		np.array([0.3113, 0.3910, 0.4272, 0.4859, 0.5061, 0.4652, 0.5362, 0.5715, 0.5661]       )

					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 					a_  (							self   :					Dict       ):



					"""simple docstring"""

					A_  :				str	   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
					A_  :				Dict	   =		self.dummy_cond_unet_upscale
					A_  :				Dict	   =		DDPMScheduler()
					A_  :				int	   =		DDIMScheduler(prediction_type='''v_prediction'''       )
					A_  :				Dict	   =		self.dummy_vae
					A_  :				Dict	   =		self.dummy_text_encoder
					A_  :				Dict	   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

					A_  :				Optional[Any]	   =		self.dummy_image.cpu().permute(0      ,     2      ,     3      ,     1       )[0]
					A_  :				Optional[int]	   =		Image.fromarray(np.uinta(_lowerCamelCase       )       ).convert('''RGB'''       ).resize((64, 64)       )

					# make sure here that pndm scheduler skips prk
					A_  :				int	   =		StableDiffusionUpscalePipeline(
					    unet=_lowerCamelCase      ,     low_res_scheduler=_lowerCamelCase      ,     scheduler=_lowerCamelCase      ,     vae=_lowerCamelCase      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase      ,     max_noise_level=3_50      ,     )
					A_  :				Dict	   =		sd_pipe.to(_lowerCamelCase       )
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase       )

					A_  :				Any	   =		'''A painting of a squirrel eating a burger'''
					A_  :				Optional[int]	   =		sd_pipe(
					    2 * [prompt]      ,     image=2 * [low_res_image]      ,     guidance_scale=6.0      ,     noise_level=20      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )
					A_  :				Tuple	   =		output.images
					assert image.shape[0] == 2

					A_  :				List[Any]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				Dict	   =		sd_pipe(
					    [prompt]      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_images_per_prompt=2      ,     guidance_scale=6.0      ,     noise_level=20      ,     num_inference_steps=2      ,     output_type='''np'''      ,     )
					A_  :				Any	   =		output.images
					assert image.shape[0] == 2







				@unittest.skipIf(torch_device != '''cuda'''      ,     '''This test requires a GPU'''       )
				def 					a_  (							self   :					Dict       ):



					"""simple docstring"""

					A_  :				List[str]	   =		self.dummy_cond_unet_upscale
					A_  :				Dict	   =		DDPMScheduler()
					A_  :				Any	   =		DDIMScheduler(prediction_type='''v_prediction'''       )
					A_  :				Dict	   =		self.dummy_vae
					A_  :				Any	   =		self.dummy_text_encoder
					A_  :				Tuple	   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )

					A_  :				List[Any]	   =		self.dummy_image.cpu().permute(0      ,     2      ,     3      ,     1       )[0]
					A_  :				Dict	   =		Image.fromarray(np.uinta(_lowerCamelCase       )       ).convert('''RGB'''       ).resize((64, 64)       )

					# put models in fp16, except vae as it overflows in fp16
					A_  :				Union[str, Any]	   =		unet.half()
					A_  :				int	   =		text_encoder.half()

					# make sure here that pndm scheduler skips prk
					A_  :				Optional[Any]	   =		StableDiffusionUpscalePipeline(
					    unet=_lowerCamelCase      ,     low_res_scheduler=_lowerCamelCase      ,     scheduler=_lowerCamelCase      ,     vae=_lowerCamelCase      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase      ,     max_noise_level=3_50      ,     )
					A_  :				Tuple	   =		sd_pipe.to(_lowerCamelCase       )
					sd_pipe.set_progress_bar_config(disable=_lowerCamelCase       )

					A_  :				Optional[Any]	   =		'''A painting of a squirrel eating a burger'''
					A_  :				Union[str, Any]	   =		torch.manual_seed(0       )
					A_  :				Optional[Any]	   =		sd_pipe(
					    [prompt]      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''      ,     ).images

					A_  :				Tuple	   =		low_res_image.size[0] * 4
					assert image.shape == (1, expected_height_width, expected_height_width, 3)

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







				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

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







				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

					A_  :				Tuple	   =		load_image(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/sd2-upscale/low_res_cat.png'''       )
					A_  :				Dict	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
					    '''/upsampled_cat.npy'''       )

					A_  :				Optional[Any]	   =		'''stabilityai/stable-diffusion-x4-upscaler'''
					A_  :				int	   =		StableDiffusionUpscalePipeline.from_pretrained(_lowerCamelCase       )
					pipe.to(_lowerCamelCase       )
					pipe.set_progress_bar_config(disable=_lowerCamelCase       )
					pipe.enable_attention_slicing()

					A_  :				Any	   =		'''a cat sitting on a park bench'''

					A_  :				List[Any]	   =		torch.manual_seed(0       )
					A_  :				List[str]	   =		pipe(
					    prompt=_lowerCamelCase      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )
					A_  :				Any	   =		output.images[0]

					assert image.shape == (5_12, 5_12, 3)
					assert np.abs(expected_image - image       ).max() < 1E-3







				def 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					A_  :				List[str]	   =		load_image(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/sd2-upscale/low_res_cat.png'''       )
					A_  :				Tuple	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-upscale'''
					    '''/upsampled_cat_fp16.npy'''       )

					A_  :				Dict	   =		'''stabilityai/stable-diffusion-x4-upscaler'''
					A_  :				Any	   =		StableDiffusionUpscalePipeline.from_pretrained(
					    _lowerCamelCase      ,     torch_dtype=torch.floataa      ,     )
					pipe.to(_lowerCamelCase       )
					pipe.set_progress_bar_config(disable=_lowerCamelCase       )
					pipe.enable_attention_slicing()

					A_  :				Any	   =		'''a cat sitting on a park bench'''

					A_  :				str	   =		torch.manual_seed(0       )
					A_  :				str	   =		pipe(
					    prompt=_lowerCamelCase      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )
					A_  :				List[str]	   =		output.images[0]

					assert image.shape == (5_12, 5_12, 3)
					assert np.abs(expected_image - image       ).max() < 5E-1







				def 					a_  (							self   :					str       ):



					"""simple docstring"""

					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()

					A_  :				List[Any]	   =		load_image(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/sd2-upscale/low_res_cat.png'''       )

					A_  :				Optional[int]	   =		'''stabilityai/stable-diffusion-x4-upscaler'''
					A_  :				Union[str, Any]	   =		StableDiffusionUpscalePipeline.from_pretrained(
					    _lowerCamelCase      ,     torch_dtype=torch.floataa      ,     )
					pipe.to(_lowerCamelCase       )
					pipe.set_progress_bar_config(disable=_lowerCamelCase       )
					pipe.enable_attention_slicing(1       )
					pipe.enable_sequential_cpu_offload()

					A_  :				int	   =		'''a cat sitting on a park bench'''

					A_  :				int	   =		torch.manual_seed(0       )
					A_  :				Any	   =		pipe(
					    prompt=_lowerCamelCase      ,     image=_lowerCamelCase      ,     generator=_lowerCamelCase      ,     num_inference_steps=5      ,     output_type='''np'''      ,     )

					A_  :				List[Any]	   =		torch.cuda.max_memory_allocated()
					# make sure that less than 2.9 GB is allocated
					assert mem_bytes < 2.9 * 10**9











"""simple docstring"""

import gc
import unittest

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

from diffusers import TransformeraDModel, VQDiffusionPipeline, VQDiffusionScheduler, VQModel
from diffusers.pipelines.vq_diffusion.pipeline_vq_diffusion import LearnedClassifierFreeSamplingEmbeddings
from diffusers.utils import load_numpy, slow, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


_lowerCamelCase  :			Any        =       False

class        lowercase      (    unittest.TestCase):







				def 					a_  (							self   :					Tuple       ):



					"""simple docstring"""

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







				@property
				def 					a_  (							self   :					Any       ):



					"""simple docstring"""

					return 12







				@property
				def 					a_  (							self   :					List[str]       ):



					"""simple docstring"""

					return 12







				@property
				def 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					return 32







				@property
				def 					a_  (							self   :					Any       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				Union[str, Any]	   =		VQModel(
					    block_out_channels=[32, 64]      ,     in_channels=3      ,     out_channels=3      ,     down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']      ,     up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']      ,     latent_channels=3      ,     num_vq_embeddings=self.num_embed      ,     vq_embed_dim=3      ,     )
					return model







				@property
				def 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					A_  :				int	   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''       )
					return tokenizer







				@property
				def 					a_  (							self   :					int       ):



					"""simple docstring"""

					torch.manual_seed(0       )
					A_  :				Optional[int]	   =		CLIPTextConfig(
					    bos_token_id=0      ,     eos_token_id=2      ,     hidden_size=self.text_embedder_hidden_size      ,     intermediate_size=37      ,     layer_norm_eps=1E-05      ,     num_attention_heads=4      ,     num_hidden_layers=5      ,     pad_token_id=1      ,     vocab_size=10_00      ,     )
					return CLIPTextModel(_lowerCamelCase       )







				@property
				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

					torch.manual_seed(0       )

					A_  :				Optional[Any]	   =		12
					A_  :				Optional[int]	   =		12

					A_  :				int	   =		{
					    '''attention_bias''': True,
					    '''cross_attention_dim''': 32,
					    '''attention_head_dim''': height * width,
					    '''num_attention_heads''': 1,
					    '''num_vector_embeds''': self.num_embed,
					    '''num_embeds_ada_norm''': self.num_embeds_ada_norm,
					    '''norm_num_groups''': 32,
					    '''sample_size''': width,
					    '''activation_fn''': '''geglu-approximate''',
					}

					A_  :				Tuple	   =		TransformeraDModel(**_lowerCamelCase       )
					return model







				def 					a_  (							self   :					Optional[int]       ):



					"""simple docstring"""

					A_  :				Union[str, Any]	   =		'''cpu'''

					A_  :				Union[str, Any]	   =		self.dummy_vqvae
					A_  :				str	   =		self.dummy_text_encoder
					A_  :				List[Any]	   =		self.dummy_tokenizer
					A_  :				int	   =		self.dummy_transformer
					A_  :				Any	   =		VQDiffusionScheduler(self.num_embed       )
					A_  :				Optional[Any]	   =		LearnedClassifierFreeSamplingEmbeddings(learnable=_lowerCamelCase       )

					A_  :				Dict	   =		VQDiffusionPipeline(
					    vqvae=_lowerCamelCase      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase      ,     transformer=_lowerCamelCase      ,     scheduler=_lowerCamelCase      ,     learned_classifier_free_sampling_embeddings=_lowerCamelCase      ,     )
					A_  :				List[Any]	   =		pipe.to(_lowerCamelCase       )
					pipe.set_progress_bar_config(disable=_lowerCamelCase       )

					A_  :				List[Any]	   =		'''teddy bear playing in the pool'''

					A_  :				List[Any]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				List[Any]	   =		pipe([prompt]      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''       )
					A_  :				Any	   =		output.images

					A_  :				List[str]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				List[Any]	   =		pipe(
					    [prompt]      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     return_dict=_lowerCamelCase      ,     num_inference_steps=2       )[0]

					A_  :				Optional[int]	   =		image[0, -3:, -3:, -1]
					A_  :				Optional[int]	   =		image_from_tuple[0, -3:, -3:, -1]

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

					A_  :				Optional[int]	   =		np.array([0.6551, 0.6168, 0.5008, 0.5676, 0.5659, 0.4295, 0.6073, 0.5599, 0.4992]       )

					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 					a_  (							self   :					List[Any]       ):



					"""simple docstring"""

					A_  :				Union[str, Any]	   =		'''cpu'''

					A_  :				int	   =		self.dummy_vqvae
					A_  :				List[str]	   =		self.dummy_text_encoder
					A_  :				Optional[Any]	   =		self.dummy_tokenizer
					A_  :				Any	   =		self.dummy_transformer
					A_  :				Any	   =		VQDiffusionScheduler(self.num_embed       )
					A_  :				Optional[int]	   =		LearnedClassifierFreeSamplingEmbeddings(
					    learnable=_lowerCamelCase      ,     hidden_size=self.text_embedder_hidden_size      ,     length=tokenizer.model_max_length       )

					A_  :				int	   =		VQDiffusionPipeline(
					    vqvae=_lowerCamelCase      ,     text_encoder=_lowerCamelCase      ,     tokenizer=_lowerCamelCase      ,     transformer=_lowerCamelCase      ,     scheduler=_lowerCamelCase      ,     learned_classifier_free_sampling_embeddings=_lowerCamelCase      ,     )
					A_  :				List[Any]	   =		pipe.to(_lowerCamelCase       )
					pipe.set_progress_bar_config(disable=_lowerCamelCase       )

					A_  :				Any	   =		'''teddy bear playing in the pool'''

					A_  :				str	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				Optional[Any]	   =		pipe([prompt]      ,     generator=_lowerCamelCase      ,     num_inference_steps=2      ,     output_type='''np'''       )
					A_  :				Tuple	   =		output.images

					A_  :				Optional[int]	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				List[str]	   =		pipe(
					    [prompt]      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     return_dict=_lowerCamelCase      ,     num_inference_steps=2       )[0]

					A_  :				Optional[int]	   =		image[0, -3:, -3:, -1]
					A_  :				Optional[Any]	   =		image_from_tuple[0, -3:, -3:, -1]

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

					A_  :				str	   =		np.array([0.6693, 0.6075, 0.4959, 0.5701, 0.5583, 0.4333, 0.6171, 0.5684, 0.4988]       )

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

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







				def 					a_  (							self   :					Any       ):



					"""simple docstring"""

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







				def 					a_  (							self   :					str       ):



					"""simple docstring"""

					A_  :				str	   =		load_numpy(
					    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
					    '''/vq_diffusion/teddy_bear_pool_classifier_free_sampling.npy'''       )

					A_  :				int	   =		VQDiffusionPipeline.from_pretrained('''microsoft/vq-diffusion-ithq'''       )
					A_  :				Tuple	   =		pipeline.to(_lowerCamelCase       )
					pipeline.set_progress_bar_config(disable=_lowerCamelCase       )

					# requires GPU generator for gumbel softmax
					# don't use GPU generator in tests though
					A_  :				Dict	   =		torch.Generator(device=_lowerCamelCase       ).manual_seed(0       )
					A_  :				Union[str, Any]	   =		pipeline(
					    '''teddy bear playing in the pool'''      ,     num_images_per_prompt=1      ,     generator=_lowerCamelCase      ,     output_type='''np'''      ,     )

					A_  :				Optional[int]	   =		output.images[0]

					assert image.shape == (2_56, 2_56, 3)
					assert np.abs(expected_image - image       ).max() < 2.0





