



'''simple docstring'''






import gc
import random
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()

class 				SCREAMING_SNAKE_CASE(							A__							,		A__							,		A__							,		unittest.TestCase			):







	"""simple docstring"""






	lowerCamelCase__			 =       StableUnCLIPImgaImgPipeline
	lowerCamelCase__			 =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS
	lowerCamelCase__			 =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	lowerCamelCase__			 =       frozenset(
	    []			)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	lowerCamelCase__			 =       frozenset([]			)







	def      A	(						self			:     int		)			->		Dict:
								UpperCAmelCase :       List[Any] 							=		32
								UpperCAmelCase :       Union[str, Any] 							=		embedder_hidden_size

								# image encoding components

								UpperCAmelCase :       Tuple 							=		CLIPImageProcessor(crop_size=32		,			size=32		)

								torch.manual_seed(0		)
								UpperCAmelCase :       Any 							=		CLIPVisionModelWithProjection(
								    CLIPVisionConfig(
								        hidden_size=__snake_case		,			projection_dim=__snake_case		,			num_hidden_layers=5		,			num_attention_heads=4		,			image_size=32		,			intermediate_size=37		,			patch_size=1		,			)		)

								# regular denoising components

								torch.manual_seed(0		)
								UpperCAmelCase :       Tuple 							=		StableUnCLIPImageNormalizer(embedding_dim=__snake_case		)
								UpperCAmelCase :       Union[str, Any] 							=		DDPMScheduler(beta_schedule='''squaredcos_cap_v2'''		)

								torch.manual_seed(0		)
								UpperCAmelCase :       List[Any] 							=		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)

								torch.manual_seed(0		)
								UpperCAmelCase :       Tuple 							=		CLIPTextModel(
								    CLIPTextConfig(
								        bos_token_id=0		,			eos_token_id=2		,			hidden_size=__snake_case		,			projection_dim=32		,			intermediate_size=37		,			layer_norm_eps=1E-05		,			num_attention_heads=4		,			num_hidden_layers=5		,			pad_token_id=1		,			vocab_size=1000		,			)		)

								torch.manual_seed(0		)
								UpperCAmelCase :       Optional[int] 							=		UNetaDConditionModel(
								    sample_size=32		,			in_channels=4		,			out_channels=4		,			down_block_types=('''CrossAttnDownBlock2D''', '''DownBlock2D''')		,			up_block_types=('''UpBlock2D''', '''CrossAttnUpBlock2D''')		,			block_out_channels=(32, 64)		,			attention_head_dim=(2, 4)		,			class_embed_type='''projection'''		,			projection_class_embeddings_input_dim=embedder_projection_dim * 2		,			cross_attention_dim=__snake_case		,			layers_per_block=1		,			upcast_attention=__snake_case		,			use_linear_projection=__snake_case		,			)

								torch.manual_seed(0		)
								UpperCAmelCase :       Any 							=		DDIMScheduler(
								    beta_schedule='''scaled_linear'''		,			beta_start=0.0_00_85		,			beta_end=0.0_12		,			prediction_type='''v_prediction'''		,			set_alpha_to_one=__snake_case		,			steps_offset=1		,			)

								torch.manual_seed(0		)
								UpperCAmelCase :       Tuple 							=		AutoencoderKL()

								UpperCAmelCase :       str 							=		{
								    # image encoding components
								    '''feature_extractor''': feature_extractor,
								    '''image_encoder''': image_encoder.eval(),
								    # image noising components
								    '''image_normalizer''': image_normalizer.eval(),
								    '''image_noising_scheduler''': image_noising_scheduler,
								    # regular denoising components
								    '''tokenizer''': tokenizer,
								    '''text_encoder''': text_encoder.eval(),
								    '''unet''': unet.eval(),
								    '''scheduler''': scheduler,
								    '''vae''': vae.eval(),
								}

								return components







	def      A	(						self			:     Dict		,			__snake_case			:     int		,			__snake_case			:     Union[str, Any]=0		,			__snake_case			:     Union[str, Any]=True		)			->		str:
								if str(__snake_case		).startswith('''mps'''		):
															UpperCAmelCase :       Tuple 							=		torch.manual_seed(__snake_case		)
								else:
															UpperCAmelCase :       List[str] 							=		torch.Generator(device=__snake_case		).manual_seed(__snake_case		)

								UpperCAmelCase :       int 							=		floats_tensor((1, 3, 32, 32)		,			rng=random.Random(__snake_case		)		).to(__snake_case		)

								if pil_image:
															UpperCAmelCase :       List[Any] 							=		input_image * 0.5 + 0.5
															UpperCAmelCase :       int 							=		input_image.clamp(0		,			1		)
															UpperCAmelCase :       Optional[int] 							=		input_image.cpu().permute(0		,			2		,			3		,			1		).float().numpy()
															UpperCAmelCase :       List[Any] 							=		DiffusionPipeline.numpy_to_pil(__snake_case		)[0]

								return {
								    "prompt": "An anime racoon running a marathon",
								    "image": input_image,
								    "generator": generator,
								    "num_inference_steps": 2,
								    "output_type": "np",
								}







	@skip_mps
	def      A	(						self			:     List[str]		)			->		Optional[Any]:
								UpperCAmelCase :       Dict 							=		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
								UpperCAmelCase :       List[str] 							=		self.get_dummy_components()
								UpperCAmelCase :       int 							=		StableUnCLIPImgaImgPipeline(**__snake_case		)
								UpperCAmelCase :       Union[str, Any] 							=		sd_pipe.to(__snake_case		)
								sd_pipe.set_progress_bar_config(disable=__snake_case		)

								UpperCAmelCase :       int 							=		self.get_dummy_inputs(__snake_case		)
								inputs.update({'''image_embeds''': None}		)
								UpperCAmelCase :       int 							=		sd_pipe(**__snake_case		).images
								UpperCAmelCase :       Optional[int] 							=		image[0, -3:, -3:, -1]

								assert image.shape == (1, 32, 32, 3)
								UpperCAmelCase :       List[Any] 							=		np.array([0.38_72, 0.72_24, 0.56_01, 0.47_41, 0.68_72, 0.58_14, 0.46_36, 0.38_67, 0.50_78]		)

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







	def      A	(						self			:     Optional[int]		)			->		Dict:
								UpperCAmelCase :       List[str] 							=		torch_device in ['''cpu''', '''mps''']

								self._test_attention_slicing_forward_pass(test_max_difference=__snake_case		)







	def      A	(						self			:     Any		)			->		Optional[Any]:
								UpperCAmelCase :       List[str] 							=		torch_device in ['''cpu''', '''mps''']

								self._test_inference_batch_single_identical(test_max_difference=__snake_case		)







	@unittest.skipIf(
	    torch_device != '''cuda''' or not is_xformers_available()		,			reason='''XFormers attention is only available with CUDA and `xformers` installed'''		,			)
	def      A	(						self			:     Optional[Any]		)			->		Any:
								self._test_xformers_attention_forwardGenerator_pass(test_max_difference=__snake_case		)

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







	"""simple docstring"""






	def      A	(						self			:     int		)			->		List[str]:
								# clean up the VRAM after each test
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()







	def      A	(						self			:     List[str]		)			->		List[Any]:
								UpperCAmelCase :       int 							=		load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'''		)

								UpperCAmelCase :       Optional[int] 							=		load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'''		)

								UpperCAmelCase :       Any 							=		StableUnCLIPImgaImgPipeline.from_pretrained(
								    '''fusing/stable-unclip-2-1-l-img2img'''		,			torch_dtype=torch.floataa		)
								pipe.to(__snake_case		)
								pipe.set_progress_bar_config(disable=__snake_case		)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase :       Dict 							=		torch.Generator(device='''cpu'''		).manual_seed(0		)
								UpperCAmelCase :       Optional[Any] 							=		pipe(__snake_case		,			'''anime turle'''		,			generator=__snake_case		,			output_type='''np'''		)

								UpperCAmelCase :       Any 							=		output.images[0]

								assert image.shape == (768, 768, 3)

								assert_mean_pixel_difference(__snake_case		,			__snake_case		)







	def      A	(						self			:     Optional[int]		)			->		Dict:
								UpperCAmelCase :       Optional[int] 							=		load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'''		)

								UpperCAmelCase :       Optional[int] 							=		load_numpy(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'''		)

								UpperCAmelCase :       Dict 							=		StableUnCLIPImgaImgPipeline.from_pretrained(
								    '''fusing/stable-unclip-2-1-h-img2img'''		,			torch_dtype=torch.floataa		)
								pipe.to(__snake_case		)
								pipe.set_progress_bar_config(disable=__snake_case		)
								# stable unclip will oom when integration tests are run on a V100,
								# so turn on memory savings
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase :       Dict 							=		torch.Generator(device='''cpu'''		).manual_seed(0		)
								UpperCAmelCase :       Union[str, Any] 							=		pipe(__snake_case		,			'''anime turle'''		,			generator=__snake_case		,			output_type='''np'''		)

								UpperCAmelCase :       Optional[Any] 							=		output.images[0]

								assert image.shape == (768, 768, 3)

								assert_mean_pixel_difference(__snake_case		,			__snake_case		)







	def      A	(						self			:     Union[str, Any]		)			->		Union[str, Any]:
								UpperCAmelCase :       Optional[int] 							=		load_image(
								    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'''		)

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

								UpperCAmelCase :       List[str] 							=		StableUnCLIPImgaImgPipeline.from_pretrained(
								    '''fusing/stable-unclip-2-1-h-img2img'''		,			torch_dtype=torch.floataa		)
								UpperCAmelCase :       Dict 							=		pipe.to(__snake_case		)
								pipe.set_progress_bar_config(disable=__snake_case		)
								pipe.enable_attention_slicing()
								pipe.enable_sequential_cpu_offload()

								UpperCAmelCase :       List[Any] 							=		pipe(
								    __snake_case		,			'''anime turtle'''		,			num_inference_steps=2		,			output_type='''np'''		,			)

								UpperCAmelCase :       Any 							=		torch.cuda.max_memory_allocated()
								# make sure that less than 7 GB is allocated
								assert mem_bytes < 7 * 10**9










'''simple docstring'''






import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
						import jax.numpy as jnp

if is_tf_available():
						import tensorflow as tf

if is_torch_available():
						import torch

class 				SCREAMING_SNAKE_CASE(							unittest.TestCase			):







	"""simple docstring"""






	def      A	(						self			:     Any		)			->		str:
								UpperCAmelCase :       Any 							=		{
								    '''task_specific_params''': {
								        '''summarization''': {'''length_penalty''': 1.0, '''max_length''': 128, '''min_length''': 12, '''num_beams''': 4},
								        '''summarization_cnn''': {'''length_penalty''': 2.0, '''max_length''': 142, '''min_length''': 56, '''num_beams''': 4},
								        '''summarization_xsum''': {'''length_penalty''': 1.0, '''max_length''': 62, '''min_length''': 11, '''num_beams''': 6},
								    }
								}
								UpperCAmelCase :       int 							=		{
								    '''task_specific_params.summarization.length_penalty''': 1.0,
								    '''task_specific_params.summarization.max_length''': 128,
								    '''task_specific_params.summarization.min_length''': 12,
								    '''task_specific_params.summarization.num_beams''': 4,
								    '''task_specific_params.summarization_cnn.length_penalty''': 2.0,
								    '''task_specific_params.summarization_cnn.max_length''': 142,
								    '''task_specific_params.summarization_cnn.min_length''': 56,
								    '''task_specific_params.summarization_cnn.num_beams''': 4,
								    '''task_specific_params.summarization_xsum.length_penalty''': 1.0,
								    '''task_specific_params.summarization_xsum.max_length''': 62,
								    '''task_specific_params.summarization_xsum.min_length''': 11,
								    '''task_specific_params.summarization_xsum.num_beams''': 6,
								}

								self.assertEqual(flatten_dict(__snake_case		)		,			__snake_case		)







	def      A	(						self			:     int		)			->		str:
								UpperCAmelCase :       Any 							=		np.random.randn(3		,			4		)
								self.assertTrue(np.allclose(transpose(__snake_case		)		,			x.transpose()		)		)

								UpperCAmelCase :       str 							=		np.random.randn(3		,			4		,			5		)
								self.assertTrue(np.allclose(transpose(__snake_case		,			axes=(1, 2, 0)		)		,			x.transpose((1, 2, 0)		)		)		)







	@require_torch
	def      A	(						self			:     str		)			->		Union[str, Any]:
								UpperCAmelCase :       Any 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       List[Any] 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		)		,			transpose(__snake_case		).numpy()		)		)

								UpperCAmelCase :       Tuple 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       Any 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		,			axes=(1, 2, 0)		)		,			transpose(__snake_case		,			axes=(1, 2, 0)		).numpy()		)		)







	@require_tf
	def      A	(						self			:     List[str]		)			->		Optional[Any]:
								UpperCAmelCase :       int 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       Optional[int] 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		)		,			transpose(__snake_case		).numpy()		)		)

								UpperCAmelCase :       Union[str, Any] 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       str 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		,			axes=(1, 2, 0)		)		,			transpose(__snake_case		,			axes=(1, 2, 0)		).numpy()		)		)







	@require_flax
	def      A	(						self			:     Tuple		)			->		Any:
								UpperCAmelCase :       List[Any] 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       List[str] 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		)		,			np.asarray(transpose(__snake_case		)		)		)		)

								UpperCAmelCase :       Dict 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       int 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(transpose(__snake_case		,			axes=(1, 2, 0)		)		,			np.asarray(transpose(__snake_case		,			axes=(1, 2, 0)		)		)		)		)







	def      A	(						self			:     Optional[Any]		)			->		Any:
								UpperCAmelCase :       Union[str, Any] 							=		np.random.randn(3		,			4		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(4, 3)		)		,			np.reshape(__snake_case		,			(4, 3)		)		)		)

								UpperCAmelCase :       Union[str, Any] 							=		np.random.randn(3		,			4		,			5		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(12, 5)		)		,			np.reshape(__snake_case		,			(12, 5)		)		)		)







	@require_torch
	def      A	(						self			:     Union[str, Any]		)			->		int:
								UpperCAmelCase :       Dict 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       Optional[Any] 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(4, 3)		)		,			reshape(__snake_case		,			(4, 3)		).numpy()		)		)

								UpperCAmelCase :       List[str] 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       List[Any] 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(12, 5)		)		,			reshape(__snake_case		,			(12, 5)		).numpy()		)		)







	@require_tf
	def      A	(						self			:     int		)			->		List[str]:
								UpperCAmelCase :       List[Any] 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       List[str] 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(4, 3)		)		,			reshape(__snake_case		,			(4, 3)		).numpy()		)		)

								UpperCAmelCase :       List[Any] 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       Optional[Any] 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(12, 5)		)		,			reshape(__snake_case		,			(12, 5)		).numpy()		)		)







	@require_flax
	def      A	(						self			:     Any		)			->		Dict:
								UpperCAmelCase :       Tuple 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       Union[str, Any] 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(4, 3)		)		,			np.asarray(reshape(__snake_case		,			(4, 3)		)		)		)		)

								UpperCAmelCase :       Any 							=		np.random.randn(3		,			4		,			5		)
								UpperCAmelCase :       Optional[Any] 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(reshape(__snake_case		,			(12, 5)		)		,			np.asarray(reshape(__snake_case		,			(12, 5)		)		)		)		)







	def      A	(						self			:     List[Any]		)			->		List[Any]:
								UpperCAmelCase :       Union[str, Any] 							=		np.random.randn(1		,			3		,			4		)
								self.assertTrue(np.allclose(squeeze(__snake_case		)		,			np.squeeze(__snake_case		)		)		)

								UpperCAmelCase :       str 							=		np.random.randn(1		,			4		,			1		,			5		)
								self.assertTrue(np.allclose(squeeze(__snake_case		,			axis=2		)		,			np.squeeze(__snake_case		,			axis=2		)		)		)







	@require_torch
	def      A	(						self			:     Optional[int]		)			->		Union[str, Any]:
								UpperCAmelCase :       Optional[int] 							=		np.random.randn(1		,			3		,			4		)
								UpperCAmelCase :       List[str] 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		)		,			squeeze(__snake_case		).numpy()		)		)

								UpperCAmelCase :       Any 							=		np.random.randn(1		,			4		,			1		,			5		)
								UpperCAmelCase :       str 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		,			axis=2		)		,			squeeze(__snake_case		,			axis=2		).numpy()		)		)







	@require_tf
	def      A	(						self			:     Optional[Any]		)			->		Dict:
								UpperCAmelCase :       int 							=		np.random.randn(1		,			3		,			4		)
								UpperCAmelCase :       Optional[int] 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		)		,			squeeze(__snake_case		).numpy()		)		)

								UpperCAmelCase :       List[str] 							=		np.random.randn(1		,			4		,			1		,			5		)
								UpperCAmelCase :       Optional[int] 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		,			axis=2		)		,			squeeze(__snake_case		,			axis=2		).numpy()		)		)







	@require_flax
	def      A	(						self			:     List[Any]		)			->		Dict:
								UpperCAmelCase :       Optional[int] 							=		np.random.randn(1		,			3		,			4		)
								UpperCAmelCase :       int 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		)		,			np.asarray(squeeze(__snake_case		)		)		)		)

								UpperCAmelCase :       str 							=		np.random.randn(1		,			4		,			1		,			5		)
								UpperCAmelCase :       int 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(squeeze(__snake_case		,			axis=2		)		,			np.asarray(squeeze(__snake_case		,			axis=2		)		)		)		)







	def      A	(						self			:     Optional[Any]		)			->		int:
								UpperCAmelCase :       Optional[Any] 							=		np.random.randn(3		,			4		)
								self.assertTrue(np.allclose(expand_dims(__snake_case		,			axis=1		)		,			np.expand_dims(__snake_case		,			axis=1		)		)		)







	@require_torch
	def      A	(						self			:     List[str]		)			->		Tuple:
								UpperCAmelCase :       Tuple 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       Tuple 							=		torch.tensor(__snake_case		)
								self.assertTrue(np.allclose(expand_dims(__snake_case		,			axis=1		)		,			expand_dims(__snake_case		,			axis=1		).numpy()		)		)







	@require_tf
	def      A	(						self			:     List[str]		)			->		Union[str, Any]:
								UpperCAmelCase :       Union[str, Any] 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       Any 							=		tf.constant(__snake_case		)
								self.assertTrue(np.allclose(expand_dims(__snake_case		,			axis=1		)		,			expand_dims(__snake_case		,			axis=1		).numpy()		)		)







	@require_flax
	def      A	(						self			:     Any		)			->		List[Any]:
								UpperCAmelCase :       List[str] 							=		np.random.randn(3		,			4		)
								UpperCAmelCase :       str 							=		jnp.array(__snake_case		)
								self.assertTrue(np.allclose(expand_dims(__snake_case		,			axis=1		)		,			np.asarray(expand_dims(__snake_case		,			axis=1		)		)		)		)





