






import os
import tempfile
import unittest

import numpy as np

from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import require_flax, slow


if is_flax_available():
							import jax
							import jax.numpy as jnp
							from flax.jax_utils import replicate
							from flax.training.common_utils import shard

							from diffusers import FlaxDDIMScheduler, FlaxDiffusionPipeline, FlaxStableDiffusionPipeline
@require_flax
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								with tempfile.TemporaryDirectory() as tmpdirname:
												# pipeline has Flax weights
												lowercase__    =			FlaxDiffusionPipeline.from_pretrained(
												    '''hf-internal-testing/tiny-stable-diffusion-pipe''',  safety_checker=lowerCamelCase,  cache_dir=lowerCamelCase  )

												lowercase__    =			[t[-1] for t in os.walk(os.path.join(lowerCamelCase,  os.listdir(lowerCamelCase  )[0],  '''snapshots'''  )  )]
												lowercase__    =			[item for sublist in all_root_files for item in sublist]

												# None of the downloaded files should be a PyTorch file even if we have some here:
												# https://huggingface.co/hf-internal-testing/tiny-stable-diffusion-pipe/blob/main/unet/diffusion_pytorch_model.bin
												assert not any(f.endswith('''.bin'''  ) for f in files  )



@slow
@require_flax
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''hf-internal-testing/tiny-stable-diffusion-pipe''',  safety_checker=lowerCamelCase  )

								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.random.PRNGKey(0  )
								lowercase__    =			4

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )

								# shard inputs and rng
								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			jax.random.split(lowerCamelCase,  lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )

								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images

								assert images.shape == (num_samples, 1, 64, 64, 3)
								if jax.device_count() == 8:
												assert np.abs(np.abs(images[0, 0, :2, :2, -2:],  dtype=np.floataa  ).sum() - 4.1514745  ) < 1E-3
												assert np.abs(np.abs(lowerCamelCase,  dtype=np.floataa  ).sum() - 49947.875  ) < 5E-1

								lowercase__    =			pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]  )  )  )
								assert len(lowerCamelCase  ) == num_samples




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''flax''',  safety_checker=lowerCamelCase  )

								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.random.PRNGKey(0  )
								lowercase__    =			50

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )

								# shard inputs and rng
								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			jax.random.split(lowerCamelCase,  lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )

								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images

								assert images.shape == (num_samples, 1, 512, 512, 3)
								if jax.device_count() == 8:
												assert np.abs((np.abs(images[0, 0, :2, :2, -2:],  dtype=np.floataa  ).sum() - 0.05652401)  ) < 1E-3
												assert np.abs((np.abs(lowerCamelCase,  dtype=np.floataa  ).sum() - 2383808.2)  ) < 5E-1




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''bf16''',  dtype=jnp.bfloataa,  safety_checker=lowerCamelCase  )

								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.random.PRNGKey(0  )
								lowercase__    =			50

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )

								# shard inputs and rng
								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			jax.random.split(lowerCamelCase,  lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )

								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images

								assert images.shape == (num_samples, 1, 512, 512, 3)
								if jax.device_count() == 8:
												assert np.abs((np.abs(images[0, 0, :2, :2, -2:],  dtype=np.floataa  ).sum() - 0.04003906)  ) < 1E-3
												assert np.abs((np.abs(lowerCamelCase,  dtype=np.floataa  ).sum() - 2373516.75)  ) < 5E-1




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''bf16''',  dtype=jnp.bfloataa  )

								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.random.PRNGKey(0  )
								lowercase__    =			50

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )

								# shard inputs and rng
								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			jax.random.split(lowerCamelCase,  lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )

								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images

								assert images.shape == (num_samples, 1, 512, 512, 3)
								if jax.device_count() == 8:
												assert np.abs((np.abs(images[0, 0, :2, :2, -2:],  dtype=np.floataa  ).sum() - 0.04003906)  ) < 1E-3
												assert np.abs((np.abs(lowerCamelCase,  dtype=np.floataa  ).sum() - 2373516.75)  ) < 5E-1




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								lowercase__    =			FlaxDDIMScheduler(
								    beta_start=0.00085,  beta_end=0.012,  beta_schedule='''scaled_linear''',  set_alpha_to_one=lowerCamelCase,  steps_offset=1,  )

								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''bf16''',  dtype=jnp.bfloataa,  scheduler=lowerCamelCase,  safety_checker=lowerCamelCase,  )
								lowercase__    =			scheduler.create_state()

								lowercase__    =			scheduler_state

								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.random.PRNGKey(0  )
								lowercase__    =			50

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )

								# shard inputs and rng
								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			jax.random.split(lowerCamelCase,  lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )

								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images

								assert images.shape == (num_samples, 1, 512, 512, 3)
								if jax.device_count() == 8:
												assert np.abs((np.abs(images[0, 0, :2, :2, -2:],  dtype=np.floataa  ).sum() - 0.045043945)  ) < 1E-3
												assert np.abs((np.abs(lowerCamelCase,  dtype=np.floataa  ).sum() - 2347693.5)  ) < 5E-1




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			(
								    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
								    ''' field, close up, split lighting, cinematic'''
								)

								lowercase__    =			jax.device_count()
								lowercase__    =			num_samples * [prompt]
								lowercase__    =			jax.random.split(jax.random.PRNGKey(0  ),  lowerCamelCase  )

								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''bf16''',  dtype=jnp.bfloataa,  safety_checker=lowerCamelCase,  )

								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )
								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images
								assert images.shape == (num_samples, 1, 512, 512, 3)
								lowercase__    =			images[2, 0, 256, 10:17, 1]

								# With memory efficient attention
								lowercase__ ,						lowercase__    =			FlaxStableDiffusionPipeline.from_pretrained(
								    '''CompVis/stable-diffusion-v1-4''',  revision='''bf16''',  dtype=jnp.bfloataa,  safety_checker=lowerCamelCase,  use_memory_efficient_attention=lowerCamelCase,  )

								lowercase__    =			replicate(lowerCamelCase  )
								lowercase__    =			pipeline.prepare_inputs(lowerCamelCase  )
								lowercase__    =			shard(lowerCamelCase  )
								lowercase__    =			pipeline(lowerCamelCase,  lowerCamelCase,  lowerCamelCase,  jit=lowerCamelCase  ).images
								assert images_eff.shape == (num_samples, 1, 512, 512, 3)
								lowercase__    =			images[2, 0, 256, 10:17, 1]

								# I checked the results visually and they are very similar. However, I saw that the max diff is `1` and the `sum`
								# over the 8 images is exactly `256`, which is very suspicious. Testing a random slice for now.
								assert abs(slice_eff - slice  ).max() < 1E-2












import math
import time

from transformers import Trainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
							import torch_xla.core.xla_model as xm
							import torch_xla.debug.metrics as met
class       _UpperCAmelCase					(       A__	):

				"""simple docstring"""




				def __init__(     self						:    Dict,  *lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    Union[str, Any]=None,  lowerCamelCase						:    Any=None,  **lowerCamelCase						:    str  ):

								'''simple docstring'''
								super().__init__(*lowerCamelCase,  **lowerCamelCase  )
								lowercase__    =			eval_examples
								lowercase__    =			post_process_function




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    str=None,  lowerCamelCase						:    Optional[Any]=None,  lowerCamelCase						:    Union[str, Any]=None,  lowerCamelCase						:    str = "eval"  ):

								'''simple docstring'''
								lowercase__    =			self.eval_dataset if eval_dataset is None else eval_dataset
								lowercase__    =			self.get_eval_dataloader(lowerCamelCase  )
								lowercase__    =			self.eval_examples if eval_examples is None else eval_examples

								# Temporarily disable metric computation, we will do it in the loop here.
								lowercase__    =			self.compute_metrics
								lowercase__    =			None
								lowercase__    =			self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
								lowercase__    =			time.time()
								try:
												lowercase__    =			eval_loop(
												    lowerCamelCase,  description='''Evaluation''',  prediction_loss_only=True if compute_metrics is None else None,  ignore_keys=lowerCamelCase,  metric_key_prefix=lowerCamelCase,  )
								finally:
												lowercase__    =			compute_metrics
								lowercase__    =			self.args.eval_batch_size * self.args.world_size
								if F"""{metric_key_prefix}_jit_compilation_time""" in output.metrics:
												start_time += output.metrics[F"""{metric_key_prefix}_jit_compilation_time"""]
								output.metrics.update(
								    speed_metrics(
								        lowerCamelCase,  lowerCamelCase,  num_samples=output.num_samples,  num_steps=math.ceil(output.num_samples / total_batch_size  ),  )  )
								if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
												# Only the main node write the results by default
												lowercase__    =			self.post_process_function(lowerCamelCase,  lowerCamelCase,  output.predictions  )
												lowercase__    =			self.compute_metrics(lowerCamelCase  )

												# Prefix all keys with metric_key_prefix + '_'
												for key in list(metrics.keys()  ):
																if not key.startswith(F"""{metric_key_prefix}_"""  ):
																				lowercase__    =			metrics.pop(lowerCamelCase  )
												metrics.update(output.metrics  )
								else:
												lowercase__    =			output.metrics

								if self.args.should_log:
												# Only the main node log the results by default
												self.log(lowerCamelCase  )

								if self.args.tpu_metrics_debug or self.args.debug:
												# tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
												xm.master_print(met.metrics_report()  )

								lowercase__    =			self.callback_handler.on_evaluate(self.args,  self.state,  self.control,  lowerCamelCase  )
								return metrics




				def 				lowercase__   (     self						:    List[Any],  lowerCamelCase						:    Any,  lowerCamelCase						:    Dict,  lowerCamelCase						:    int=None,  lowerCamelCase						:    str = "test"  ):

								'''simple docstring'''
								lowercase__    =			self.get_test_dataloader(lowerCamelCase  )

								# Temporarily disable metric computation, we will do it in the loop here.
								lowercase__    =			self.compute_metrics
								lowercase__    =			None
								lowercase__    =			self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
								lowercase__    =			time.time()
								try:
												lowercase__    =			eval_loop(
												    lowerCamelCase,  description='''Prediction''',  prediction_loss_only=True if compute_metrics is None else None,  ignore_keys=lowerCamelCase,  metric_key_prefix=lowerCamelCase,  )
								finally:
												lowercase__    =			compute_metrics
								lowercase__    =			self.args.eval_batch_size * self.args.world_size
								if F"""{metric_key_prefix}_jit_compilation_time""" in output.metrics:
												start_time += output.metrics[F"""{metric_key_prefix}_jit_compilation_time"""]
								output.metrics.update(
								    speed_metrics(
								        lowerCamelCase,  lowerCamelCase,  num_samples=output.num_samples,  num_steps=math.ceil(output.num_samples / total_batch_size  ),  )  )

								if self.post_process_function is None or self.compute_metrics is None:
												return output

								lowercase__    =			self.post_process_function(lowerCamelCase,  lowerCamelCase,  output.predictions,  '''predict'''  )
								lowercase__    =			self.compute_metrics(lowerCamelCase  )

								# Prefix all keys with metric_key_prefix + '_'
								for key in list(metrics.keys()  ):
												if not key.startswith(F"""{metric_key_prefix}_"""  ):
																lowercase__    =			metrics.pop(lowerCamelCase  )
								metrics.update(output.metrics  )
								return PredictionOutput(predictions=predictions.predictions,  label_ids=predictions.label_ids,  metrics=lowerCamelCase  )




