



"""simple docstring"""





import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)




def 	UpperCAmelCase     (		A	:						List[Any]     ,				A	:						List[str]     ,				A	:						Optional[int]       ):

		'''simple docstring'''


		if isinstance(A     ,				torch.Tensor       ):
				return image
		elif isinstance(A     ,				PIL.Image.Image       ):
				_UpperCAmelCase							 =		[image]

		if isinstance(image[0]     ,				PIL.Image.Image       ):
				_UpperCAmelCase							 =		[np.array(i.resize((w, h)     ,				resample=PIL_INTERPOLATION['lanczos']       )       )[None, :] for i in image]
				_UpperCAmelCase							 =		np.concatenate(A     ,				axis=0       )
				_UpperCAmelCase							 =		np.array(A       ).astype(np.floataa       ) / 255.0
				_UpperCAmelCase							 =		image.transpose(0     ,				3     ,				1     ,				2       )
				_UpperCAmelCase							 =		2.0 * image - 1.0
				_UpperCAmelCase							 =		torch.from_numpy(A       )
		elif isinstance(image[0]     ,				torch.Tensor       ):
				_UpperCAmelCase							 =		torch.cat(A     ,				dim=0       )
		return image




def 	UpperCAmelCase     (		A	:						Optional[Any]     ,				A	:						Optional[int]     ,				A	:						Any     ,				A	:						Dict=0.9995       ):

		'''simple docstring'''


		if not isinstance(A     ,				np.ndarray       ):
				_UpperCAmelCase							 =		True
				_UpperCAmelCase							 =		va.device
				_UpperCAmelCase							 =		va.cpu().numpy()
				_UpperCAmelCase							 =		va.cpu().numpy()

		_UpperCAmelCase							 =		np.sum(va * va / (np.linalg.norm(A       ) * np.linalg.norm(A       ))       )
		if np.abs(A       ) > DOT_THRESHOLD:
				_UpperCAmelCase							 =		(1 - t) * va + t * va
		else:
				_UpperCAmelCase							 =		np.arccos(A       )
				_UpperCAmelCase							 =		np.sin(A       )
				_UpperCAmelCase							 =		theta_a * t
				_UpperCAmelCase							 =		np.sin(A       )
				_UpperCAmelCase							 =		np.sin(theta_a - theta_t       ) / sin_theta_a
				_UpperCAmelCase							 =		sin_theta_t / sin_theta_a
				_UpperCAmelCase							 =		sa * va + sa * va

		if inputs_are_torch:
				_UpperCAmelCase							 =		torch.from_numpy(A       ).to(A       )

		return va




def 	UpperCAmelCase     (		A	:						Union[str, Any]     ,				A	:						str       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		F.normalize(A     ,				dim=-1       )
		_UpperCAmelCase							 =		F.normalize(A     ,				dim=-1       )
		return (x - y).norm(dim=-1       ).div(2       ).arcsin().pow(2       ).mul(2       )




def 	UpperCAmelCase     (		A	:						List[str]     ,				A	:						str       ):

		'''simple docstring'''


		for param in model.parameters():
				_UpperCAmelCase							 =		value






class 			lowercase__			(      A    ):
							'''simple docstring'''







							def __init__(  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case=None	,       snake_case=None	,       snake_case=None	,       )			->							Union[str, Any]:
									super().__init__()
									self.register_modules(
									    vae=snake_case	,       text_encoder=snake_case	,       clip_model=snake_case	,       tokenizer=snake_case	,       unet=snake_case	,       scheduler=snake_case	,       feature_extractor=snake_case	,       coca_model=snake_case	,       coca_tokenizer=snake_case	,       coca_transform=snake_case	,       )
									_UpperCAmelCase							 =		(
									    feature_extractor.size
									    if isinstance(feature_extractor.size	,       snake_case						)
									    else feature_extractor.size['shortest_edge']
									)
									_UpperCAmelCase							 =		transforms.Normalize(mean=feature_extractor.image_mean	,       std=feature_extractor.image_std						)
									set_requires_grad(self.text_encoder	,       snake_case						)
									set_requires_grad(self.clip_model	,       snake_case						)






							def        lowerCamelCase_   (  self	,       snake_case = "auto"						)			->							Dict:
									if slice_size == "auto":
											# half the attention head size is usually a good trade-off between
											# speed and memory
											_UpperCAmelCase							 =		self.unet.config.attention_head_dim // 2
									self.unet.set_attention_slice(snake_case						)






							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									self.enable_attention_slicing(snake_case						)






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									set_requires_grad(self.vae	,       snake_case						)






							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									set_requires_grad(self.vae	,       snake_case						)






							def        lowerCamelCase_   (  self						)			->							Dict:
									set_requires_grad(self.unet	,       snake_case						)






							def        lowerCamelCase_   (  self						)			->							List[str]:
									set_requires_grad(self.unet	,       snake_case						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case						)			->							Any:
									# get the original timestep using init_timestep
									_UpperCAmelCase							 =		min(int(num_inference_steps * strength						)	,       snake_case						)

									_UpperCAmelCase							 =		max(num_inference_steps - init_timestep	,       0						)
									_UpperCAmelCase							 =		self.scheduler.timesteps[t_start:]

									return timesteps, num_inference_steps - t_start






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case=None						)			->							int:
									if not isinstance(snake_case	,       torch.Tensor						):
											raise ValueError(f'`image` has to be of type `torch.Tensor` but is {type(snake_case						)}'						)

									_UpperCAmelCase							 =		image.to(device=snake_case	,       dtype=snake_case						)

									if isinstance(snake_case	,       snake_case						):
											_UpperCAmelCase							 =		[
											    self.vae.encode(image[i : i + 1]						).latent_dist.sample(generator[i]						) for i in range(snake_case						)
											]
											_UpperCAmelCase							 =		torch.cat(snake_case	,       dim=0						)
									else:
											_UpperCAmelCase							 =		self.vae.encode(snake_case						).latent_dist.sample(snake_case						)

									# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
									_UpperCAmelCase							 =		0.18215 * init_latents
									_UpperCAmelCase							 =		init_latents.repeat_interleave(snake_case	,       dim=0						)

									_UpperCAmelCase							 =		randn_tensor(init_latents.shape	,       generator=snake_case	,       device=snake_case	,       dtype=snake_case						)

									# get latents
									_UpperCAmelCase							 =		self.scheduler.add_noise(snake_case	,       snake_case	,       snake_case						)
									_UpperCAmelCase							 =		init_latents

									return latents






							def        lowerCamelCase_   (  self	,       snake_case						)			->							Optional[int]:
									_UpperCAmelCase							 =		self.coca_transform(snake_case						).unsqueeze(0						)
									with torch.no_grad(), torch.cuda.amp.autocast():
											_UpperCAmelCase							 =		self.coca_model.generate(transformed_image.to(device=self.device	,       dtype=self.coca_model.dtype						)						)
									_UpperCAmelCase							 =		self.coca_tokenizer.decode(generated[0].cpu().numpy()						)
									return generated.split('<end_of_text>'						)[0].replace('<start_of_text>'	,       ''						).rstrip(' .,'						)






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Tuple:
									_UpperCAmelCase							 =		self.feature_extractor.preprocess(snake_case						)
									_UpperCAmelCase							 =		torch.from_numpy(clip_image_input['pixel_values'][0]						).unsqueeze(0						).to(self.device						).half()
									_UpperCAmelCase							 =		self.clip_model.get_image_features(snake_case						)
									_UpperCAmelCase							 =		image_embeddings_clip / image_embeddings_clip.norm(p=2	,       dim=-1	,       keepdim=snake_case						)
									_UpperCAmelCase							 =		image_embeddings_clip.repeat_interleave(snake_case	,       dim=0						)
									return image_embeddings_clip






							@torch.enable_grad()
							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       )			->							Dict:
									_UpperCAmelCase							 =		latents.detach().requires_grad_()

									_UpperCAmelCase							 =		self.scheduler.scale_model_input(snake_case	,       snake_case						)

									# predict the noise residual
									_UpperCAmelCase							 =		self.unet(snake_case	,       snake_case	,       encoder_hidden_states=snake_case						).sample

									if isinstance(self.scheduler	,       (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)						):
											_UpperCAmelCase							 =		self.scheduler.alphas_cumprod[timestep]
											_UpperCAmelCase							 =		1 - alpha_prod_t
											# compute predicted original sample from predicted noise also called
											# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
											_UpperCAmelCase							 =		(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

											_UpperCAmelCase							 =		torch.sqrt(snake_case						)
											_UpperCAmelCase							 =		pred_original_sample * (fac) + latents * (1 - fac)
									elif isinstance(self.scheduler	,       snake_case						):
											_UpperCAmelCase							 =		self.scheduler.sigmas[index]
											_UpperCAmelCase							 =		latents - sigma * noise_pred
									else:
											raise ValueError(f'scheduler type {type(self.scheduler						)} not supported'						)

									# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
									_UpperCAmelCase							 =		1 / 0.18215 * sample
									_UpperCAmelCase							 =		self.vae.decode(snake_case						).sample
									_UpperCAmelCase							 =		(image / 2 + 0.5).clamp(0	,       1						)

									_UpperCAmelCase							 =		transforms.Resize(self.feature_extractor_size						)(snake_case						)
									_UpperCAmelCase							 =		self.normalize(snake_case						).to(latents.dtype						)

									_UpperCAmelCase							 =		self.clip_model.get_image_features(snake_case						)
									_UpperCAmelCase							 =		image_embeddings_clip / image_embeddings_clip.norm(p=2	,       dim=-1	,       keepdim=snake_case						)

									_UpperCAmelCase							 =		spherical_dist_loss(snake_case	,       snake_case						).mean() * clip_guidance_scale

									_UpperCAmelCase							 =		-torch.autograd.grad(snake_case	,       snake_case						)[0]

									if isinstance(self.scheduler	,       snake_case						):
											_UpperCAmelCase							 =		latents.detach() + grads * (sigma**2)
											_UpperCAmelCase							 =		noise_pred_original
									else:
											_UpperCAmelCase							 =		noise_pred_original - torch.sqrt(snake_case						) * grads
									return noise_pred, latents






							@torch.no_grad()
							def __call__(  self	,       snake_case	,       snake_case	,       snake_case = None	,       snake_case = None	,       snake_case = 512	,       snake_case = 512	,       snake_case = 0.6	,       snake_case = 50	,       snake_case = 7.5	,       snake_case = 1	,       snake_case = 0.0	,       snake_case = 100	,       snake_case = None	,       snake_case = "pil"	,       snake_case = True	,       snake_case = 0.8	,       snake_case = 0.1	,       snake_case = 0.1	,       )			->							Tuple:
									if isinstance(snake_case	,       snake_case						) and len(snake_case						) != batch_size:
											raise ValueError(f'You have passed {batch_size} batch_size, but only {len(snake_case						)} generators.'						)

									if height % 8 != 0 or width % 8 != 0:
											raise ValueError(f'`height` and `width` have to be divisible by 8 but are {height} and {width}.'						)

									if isinstance(snake_case	,       torch.Generator						) and batch_size > 1:
											_UpperCAmelCase							 =		[generator] + [None] * (batch_size - 1)

									_UpperCAmelCase							 =		[
									    ('model', self.coca_model is None),
									    ('tokenizer', self.coca_tokenizer is None),
									    ('transform', self.coca_transform is None),
									]
									_UpperCAmelCase							 =		[x[0] for x in coca_is_none if x[1]]
									_UpperCAmelCase							 =		', '.join(snake_case						)
									# generate prompts with coca model if prompt is None
									if content_prompt is None:
											if len(snake_case						):
													raise ValueError(
													    f'Content prompt is None and CoCa [{coca_is_none_str}] is None.'
													    f'Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'						)
											_UpperCAmelCase							 =		self.get_image_description(snake_case						)
									if style_prompt is None:
											if len(snake_case						):
													raise ValueError(
													    f'Style prompt is None and CoCa [{coca_is_none_str}] is None.'
													    f' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'						)
											_UpperCAmelCase							 =		self.get_image_description(snake_case						)

									# get prompt text embeddings for content and style
									_UpperCAmelCase							 =		self.tokenizer(
									    snake_case	,       padding='max_length'	,       max_length=self.tokenizer.model_max_length	,       truncation=snake_case	,       return_tensors='pt'	,       )
									_UpperCAmelCase							 =		self.text_encoder(content_text_input.input_ids.to(self.device						)						)[0]

									_UpperCAmelCase							 =		self.tokenizer(
									    snake_case	,       padding='max_length'	,       max_length=self.tokenizer.model_max_length	,       truncation=snake_case	,       return_tensors='pt'	,       )
									_UpperCAmelCase							 =		self.text_encoder(style_text_input.input_ids.to(self.device						)						)[0]

									_UpperCAmelCase							 =		slerp(snake_case	,       snake_case	,       snake_case						)

									# duplicate text embeddings for each generation per prompt
									_UpperCAmelCase							 =		text_embeddings.repeat_interleave(snake_case	,       dim=0						)

									# set timesteps
									_UpperCAmelCase							 =		'offset' in set(inspect.signature(self.scheduler.set_timesteps						).parameters.keys()						)
									_UpperCAmelCase							 =		{}
									if accepts_offset:
											_UpperCAmelCase							 =		1

									self.scheduler.set_timesteps(snake_case	,       **snake_case						)
									# Some schedulers like PNDM have timesteps as arrays
									# It's more optimized to move all timesteps to correct device beforehand
									self.scheduler.timesteps.to(self.device						)

									_UpperCAmelCase ,					_UpperCAmelCase							 =		self.get_timesteps(snake_case	,       snake_case	,       self.device						)
									_UpperCAmelCase							 =		timesteps[:1].repeat(snake_case						)

									# Preprocess image
									_UpperCAmelCase							 =		preprocess(snake_case	,       snake_case	,       snake_case						)
									_UpperCAmelCase							 =		self.prepare_latents(
									    snake_case	,       snake_case	,       snake_case	,       text_embeddings.dtype	,       self.device	,       snake_case						)

									_UpperCAmelCase							 =		preprocess(snake_case	,       snake_case	,       snake_case						)
									_UpperCAmelCase							 =		self.prepare_latents(
									    snake_case	,       snake_case	,       snake_case	,       text_embeddings.dtype	,       self.device	,       snake_case						)

									_UpperCAmelCase							 =		slerp(snake_case	,       snake_case	,       snake_case						)

									if clip_guidance_scale > 0:
											_UpperCAmelCase							 =		self.get_clip_image_embeddings(snake_case	,       snake_case						)
											_UpperCAmelCase							 =		self.get_clip_image_embeddings(snake_case	,       snake_case						)
											_UpperCAmelCase							 =		slerp(
											    snake_case	,       snake_case	,       snake_case						)

									# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
									# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
									# corresponds to doing no classifier free guidance.
									_UpperCAmelCase							 =		guidance_scale > 1.0
									# get unconditional embeddings for classifier free guidance
									if do_classifier_free_guidance:
											_UpperCAmelCase							 =		content_text_input.input_ids.shape[-1]
											_UpperCAmelCase							 =		self.tokenizer(['']	,       padding='max_length'	,       max_length=snake_case	,       return_tensors='pt'						)
											_UpperCAmelCase							 =		self.text_encoder(uncond_input.input_ids.to(self.device						)						)[0]
											# duplicate unconditional embeddings for each generation per prompt
											_UpperCAmelCase							 =		uncond_embeddings.repeat_interleave(snake_case	,       dim=0						)

											# For classifier free guidance, we need to do two forward passes.
											# Here we concatenate the unconditional and text embeddings into a single batch
											# to avoid doing two forward passes
											_UpperCAmelCase							 =		torch.cat([uncond_embeddings, text_embeddings]						)

									# get the initial random noise unless the user supplied it

									# Unlike in other pipelines, latents need to be generated in the target device
									# for 1-to-1 results reproducibility with the CompVis implementation.
									# However this currently doesn't work in `mps`.
									_UpperCAmelCase							 =		(batch_size, self.unet.config.in_channels, height // 8, width // 8)
									_UpperCAmelCase							 =		text_embeddings.dtype
									if latents is None:
											if self.device.type == "mps":
													# randn does not work reproducibly on mps
													_UpperCAmelCase							 =		torch.randn(snake_case	,       generator=snake_case	,       device='cpu'	,       dtype=snake_case						).to(
													    self.device						)
											else:
													_UpperCAmelCase							 =		torch.randn(snake_case	,       generator=snake_case	,       device=self.device	,       dtype=snake_case						)
									else:
											if latents.shape != latents_shape:
													raise ValueError(f'Unexpected latents shape, got {latents.shape}, expected {latents_shape}'						)
											_UpperCAmelCase							 =		latents.to(self.device						)

									# scale the initial noise by the standard deviation required by the scheduler
									_UpperCAmelCase							 =		latents * self.scheduler.init_noise_sigma

									# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
									# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
									# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
									# and should be between [0, 1]
									_UpperCAmelCase							 =		'eta' in set(inspect.signature(self.scheduler.step						).parameters.keys()						)
									_UpperCAmelCase							 =		{}
									if accepts_eta:
											_UpperCAmelCase							 =		eta

									# check if the scheduler accepts generator
									_UpperCAmelCase							 =		'generator' in set(inspect.signature(self.scheduler.step						).parameters.keys()						)
									if accepts_generator:
											_UpperCAmelCase							 =		generator

									with self.progress_bar(total=snake_case						):
											for i, t in enumerate(snake_case						):
													# expand the latents if we are doing classifier free guidance
													_UpperCAmelCase							 =		torch.cat([latents] * 2						) if do_classifier_free_guidance else latents
													_UpperCAmelCase							 =		self.scheduler.scale_model_input(snake_case	,       snake_case						)

													# predict the noise residual
													_UpperCAmelCase							 =		self.unet(snake_case	,       snake_case	,       encoder_hidden_states=snake_case						).sample

													# perform classifier free guidance
													if do_classifier_free_guidance:
															_UpperCAmelCase ,					_UpperCAmelCase							 =		noise_pred.chunk(2						)
															_UpperCAmelCase							 =		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

													# perform clip guidance
													if clip_guidance_scale > 0:
															_UpperCAmelCase							 =		(
															    text_embeddings.chunk(2						)[1] if do_classifier_free_guidance else text_embeddings
															)
															_UpperCAmelCase ,					_UpperCAmelCase							 =		self.cond_fn(
															    snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       snake_case	,       )

													# compute the previous noisy sample x_t -> x_t-1
													_UpperCAmelCase							 =		self.scheduler.step(snake_case	,       snake_case	,       snake_case	,       **snake_case						).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
									_UpperCAmelCase							 =		1 / 0.18215 * latents
									_UpperCAmelCase							 =		self.vae.decode(snake_case						).sample

									_UpperCAmelCase							 =		(image / 2 + 0.5).clamp(0	,       1						)
									_UpperCAmelCase							 =		image.cpu().permute(0	,       2	,       3	,       1						).numpy()

									if output_type == "pil":
											_UpperCAmelCase							 =		self.numpy_to_pil(snake_case						)

									if not return_dict:
											return (image, None)

									return StableDiffusionPipelineOutput(images=snake_case	,       nsfw_content_detected=snake_case						)







"""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 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							Dict:
									_UpperCAmelCase							 =		{
									    '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							 =		{
									    '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        lowerCamelCase_   (  self						)			->							List[str]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									self.assertTrue(np.allclose(transpose(snake_case						)	,       x.transpose()						)						)

									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							List[str]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(transpose(snake_case						)	,       transpose(snake_case						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(transpose(snake_case						)	,       transpose(snake_case						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(transpose(snake_case						)	,       np.asarray(transpose(snake_case						)						)						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							List[str]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (4, 3)						)	,       np.reshape(snake_case	,       (4, 3)						)						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (12, 5)						)	,       np.reshape(snake_case	,       (12, 5)						)						)						)






							@require_torch
							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (4, 3)						)	,       reshape(snake_case	,       (4, 3)						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (12, 5)						)	,       reshape(snake_case	,       (12, 5)						).numpy()						)						)






							@require_tf
							def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (4, 3)						)	,       reshape(snake_case	,       (4, 3)						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (12, 5)						)	,       reshape(snake_case	,       (12, 5)						).numpy()						)						)






							@require_flax
							def        lowerCamelCase_   (  self						)			->							Tuple:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (4, 3)						)	,       np.asarray(reshape(snake_case	,       (4, 3)						)						)						)						)

									_UpperCAmelCase							 =		np.random.randn(3	,       4	,       5						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(reshape(snake_case	,       (12, 5)						)	,       np.asarray(reshape(snake_case	,       (12, 5)						)						)						)						)






							def        lowerCamelCase_   (  self						)			->							str:
									_UpperCAmelCase							 =		np.random.randn(1	,       3	,       4						)
									self.assertTrue(np.allclose(squeeze(snake_case						)	,       np.squeeze(snake_case						)						)						)

									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		np.random.randn(1	,       3	,       4						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case						)	,       squeeze(snake_case						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(1	,       4	,       1	,       5						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case	,       axis=2						)	,       squeeze(snake_case	,       axis=2						).numpy()						)						)






							@require_tf
							def        lowerCamelCase_   (  self						)			->							Optional[int]:
									_UpperCAmelCase							 =		np.random.randn(1	,       3	,       4						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case						)	,       squeeze(snake_case						).numpy()						)						)

									_UpperCAmelCase							 =		np.random.randn(1	,       4	,       1	,       5						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case	,       axis=2						)	,       squeeze(snake_case	,       axis=2						).numpy()						)						)






							@require_flax
							def        lowerCamelCase_   (  self						)			->							str:
									_UpperCAmelCase							 =		np.random.randn(1	,       3	,       4						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case						)	,       np.asarray(squeeze(snake_case						)						)						)						)

									_UpperCAmelCase							 =		np.random.randn(1	,       4	,       1	,       5						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(squeeze(snake_case	,       axis=2						)	,       np.asarray(squeeze(snake_case	,       axis=2						)						)						)						)






							def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Dict:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		torch.tensor(snake_case						)
									self.assertTrue(np.allclose(expand_dims(snake_case	,       axis=1						)	,       expand_dims(snake_case	,       axis=1						).numpy()						)						)






							@require_tf
							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		tf.constant(snake_case						)
									self.assertTrue(np.allclose(expand_dims(snake_case	,       axis=1						)	,       expand_dims(snake_case	,       axis=1						).numpy()						)						)






							@require_flax
							def        lowerCamelCase_   (  self						)			->							str:
									_UpperCAmelCase							 =		np.random.randn(3	,       4						)
									_UpperCAmelCase							 =		jnp.array(snake_case						)
									self.assertTrue(np.allclose(expand_dims(snake_case	,       axis=1						)	,       np.asarray(expand_dims(snake_case	,       axis=1						)						)						)						)


