

import gc
import unittest

import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DDPMScheduler,
    PriorTransformer,
    StableUnCLIPPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.testing_utils import enable_full_determinism, load_numpy, require_torch_gpu, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()



class        _a		(__magic_name__						,  __magic_name__						,  __magic_name__						,  unittest.TestCase							):


					'''simple docstring'''






					UpperCAmelCase__:  List[Any]    				=			StableUnCLIPPipeline
					UpperCAmelCase__:  Optional[int]    				=			TEXT_TO_IMAGE_PARAMS
					UpperCAmelCase__:  Optional[int]    				=			TEXT_TO_IMAGE_BATCH_PARAMS
					UpperCAmelCase__:  Optional[Any]    				=			TEXT_TO_IMAGE_IMAGE_PARAMS
					UpperCAmelCase__:  str    				=			TEXT_TO_IMAGE_IMAGE_PARAMS

					# TODO(will) Expected attn_bias.stride(1) == 0 to be true, but got false
					UpperCAmelCase__:  List[Any]    				=			False






					def     __A     (					self     ):
						A__				:       Optional[int]	  =						32
						A__				:       Union[str, Any]	  =						embedder_hidden_size

						# prior components

						torch.manual_seed(0     )
						A__				:       List[str]	  =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

						torch.manual_seed(0     )
						A__				:       List[Any]	  =						CLIPTextModelWithProjection(
						    CLIPTextConfig(
						        bos_token_id=0       ,			eos_token_id=2       ,			hidden_size=A__       ,			projection_dim=A__       ,			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     )
						A__				:       int	  =						PriorTransformer(
						    num_attention_heads=2       ,			attention_head_dim=12       ,			embedding_dim=A__       ,			num_layers=1       ,			)

						torch.manual_seed(0     )
						A__				:       Optional[int]	  =						DDPMScheduler(
						    variance_type="""fixed_small_log"""       ,			prediction_type="""sample"""       ,			num_train_timesteps=1000       ,			clip_sample=A__       ,			clip_sample_range=5.0       ,			beta_schedule="""squaredcos_cap_v2"""       ,			)

						# regular denoising components

						torch.manual_seed(0     )
						A__				:       Optional[Any]	  =						StableUnCLIPImageNormalizer(embedding_dim=A__     )
						A__				:       Any	  =						DDPMScheduler(beta_schedule="""squaredcos_cap_v2"""     )

						torch.manual_seed(0     )
						A__				:       Tuple	  =						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""     )

						torch.manual_seed(0     )
						A__				:       Optional[int]	  =						CLIPTextModel(
						    CLIPTextConfig(
						        bos_token_id=0       ,			eos_token_id=2       ,			hidden_size=A__       ,			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     )
						A__				:       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=A__       ,			layers_per_block=1       ,			upcast_attention=A__       ,			use_linear_projection=A__       ,			)

						torch.manual_seed(0     )
						A__				:       List[str]	  =						DDIMScheduler(
						    beta_schedule="""scaled_linear"""       ,			beta_start=0.0_0_0_8_5       ,			beta_end=0.0_1_2       ,			prediction_type="""v_prediction"""       ,			set_alpha_to_one=A__       ,			steps_offset=1       ,			)

						torch.manual_seed(0     )
						A__				:       Any	  =						AutoencoderKL()

						A__				:       Optional[int]	  =						{
						    # prior components
						    """prior_tokenizer""": prior_tokenizer,
						    """prior_text_encoder""": prior_text_encoder,
						    """prior""": prior,
						    """prior_scheduler""": prior_scheduler,
						    # image noising components
						    """image_normalizer""": image_normalizer,
						    """image_noising_scheduler""": image_noising_scheduler,
						    # regular denoising components
						    """tokenizer""": tokenizer,
						    """text_encoder""": text_encoder,
						    """unet""": unet,
						    """scheduler""": scheduler,
						    """vae""": vae,
						}

						return components






					def     __A     (					self       ,			A__       ,			A__=0     ):
						if str(A__     ).startswith("""mps"""     ):
							A__				:       List[str]	  =						torch.manual_seed(A__     )
						else:
							A__				:       List[str]	  =						torch.Generator(device=A__     ).manual_seed(A__     )
						A__				:       Optional[Any]	  =						{
						    """prompt""": """A painting of a squirrel eating a burger""",
						    """generator""": generator,
						    """num_inference_steps""": 2,
						    """prior_num_inference_steps""": 2,
						    """output_type""": """numpy""",
						}
						return inputs






					def     __A     (					self     ):
						A__				:       int	  =						torch_device == """cpu"""

						self._test_attention_slicing_forward_pass(test_max_difference=A__     )






					def     __A     (					self     ):
						A__				:       Optional[int]	  =						torch_device in ["""cpu""", """mps"""]

						self._test_inference_batch_single_identical(test_max_difference=A__     )



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


					'''simple docstring'''






					def     __A     (					self     ):
						# clean up the VRAM after each test
						super().tearDown()
						gc.collect()
						torch.cuda.empty_cache()






					def     __A     (					self     ):
						A__				:       Dict	  =						load_numpy(
						    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_anime_turtle_fp16.npy"""     )

						A__				:       Any	  =						StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""       ,			torch_dtype=torch.floataa     )
						pipe.to(A__     )
						pipe.set_progress_bar_config(disable=A__     )
						# 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()

						A__				:       Any	  =						torch.Generator(device="""cpu"""     ).manual_seed(0     )
						A__				:       str	  =						pipe("""anime turle"""       ,			generator=A__       ,			output_type="""np"""     )

						A__				:       List[Any]	  =						output.images[0]

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

						assert_mean_pixel_difference(A__       ,			A__     )






					def     __A     (					self     ):
						torch.cuda.empty_cache()
						torch.cuda.reset_max_memory_allocated()
						torch.cuda.reset_peak_memory_stats()

						A__				:       List[Any]	  =						StableUnCLIPPipeline.from_pretrained("""fusing/stable-unclip-2-1-l"""       ,			torch_dtype=torch.floataa     )
						A__				:       Tuple	  =						pipe.to(A__     )
						pipe.set_progress_bar_config(disable=A__     )
						pipe.enable_attention_slicing()
						pipe.enable_sequential_cpu_offload()

						A__				:       Dict	  =						pipe(
						    """anime turtle"""       ,			prior_num_inference_steps=2       ,			num_inference_steps=2       ,			output_type="""np"""       ,			)

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






import json
import os
import subprocess
import unittest
from ast import literal_eval

import pytest
from parameterized import parameterized, parameterized_class

from . import is_sagemaker_available


if is_sagemaker_available():
	from sagemaker import Session, TrainingJobAnalytics
	from sagemaker.huggingface import HuggingFace



@pytest.mark.skipif(
    literal_eval(os.getenv('''TEST_SAGEMAKER'''						,  '''False'''							)							) is not True						,  reason='''Skipping test because should only be run when releasing minor transformers version'''						,  )
@pytest.mark.usefixtures('''sm_env'''							)
@parameterized_class(
    [
        {
            '''framework''': '''pytorch''',
            '''script''': '''run_glue.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_50, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''pytorch''',
            '''script''': '''run_ddp.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_00, '''eval_accuracy''': 0.7, '''eval_loss''': 0.6},
        },
        {
            '''framework''': '''tensorflow''',
            '''script''': '''run_tf_dist.py''',
            '''model_name_or_path''': '''distilbert-base-cased''',
            '''instance_type''': '''ml.p3.16xlarge''',
            '''results''': {'''train_runtime''': 6_00, '''eval_accuracy''': 0.6, '''eval_loss''': 0.7},
        },
    ]							)
class        _a		(unittest.TestCase							):


					'''simple docstring'''






					def     __A     (					self     ):
						if self.framework == "pytorch":
							subprocess.run(
							    F"""cp ./examples/pytorch/text-classification/run_glue.py {self.env.test_path}/run_glue.py""".split()       ,			encoding="""utf-8"""       ,			check=A__       ,			)
						assert hasattr(self       ,			"""env"""     )






					def     __A     (					self       ,			A__     ):
						A__				:       int	  =						F"""{self.env.base_job_name}-{instance_count}-{'ddp' if 'ddp' in self.script else 'smd'}"""
						# distributed data settings
						A__				:       str	  =						{"""smdistributed""": {"""dataparallel""": {"""enabled""": True}}} if self.script != """run_ddp.py""" else None

						# creates estimator
						return HuggingFace(
						    entry_point=self.script       ,			source_dir=self.env.test_path       ,			role=self.env.role       ,			image_uri=self.env.image_uri       ,			base_job_name=A__       ,			instance_count=A__       ,			instance_type=self.instance_type       ,			debugger_hook_config=A__       ,			hyperparameters={**self.env.distributed_hyperparameters, """model_name_or_path""": self.model_name_or_path}       ,			metric_definitions=self.env.metric_definitions       ,			distribution=A__       ,			py_version="""py36"""       ,			)






					def     __A     (					self       ,			A__     ):
						TrainingJobAnalytics(A__     ).export_csv(F"""{self.env.test_path}/{job_name}_metrics.csv"""     )






					@parameterized.expand([(2,)]     )
					def     __A     (					self       ,			A__     ):
						# create estimator
						A__				:       str	  =						self.create_estimator(A__     )

						# run training
						estimator.fit()

						# result dataframe
						A__				:       str	  =						TrainingJobAnalytics(estimator.latest_training_job.name     ).dataframe()

						# extract kpis
						A__				:       List[Any]	  =						list(result_metrics_df[result_metrics_df.metric_name == """eval_accuracy"""]["""value"""]     )
						A__				:       Optional[Any]	  =						list(result_metrics_df[result_metrics_df.metric_name == """eval_loss"""]["""value"""]     )
						# get train time from SageMaker job, this includes starting, preprocessing, stopping
						A__				:       str	  =						(
						    Session().describe_training_job(estimator.latest_training_job.name     ).get("""TrainingTimeInSeconds"""       ,			99_9999     )
						)

						# assert kpis
						assert train_runtime <= self.results["train_runtime"]
						assert all(t >= self.results["""eval_accuracy"""] for t in eval_accuracy     )
						assert all(t <= self.results["""eval_loss"""] for t in eval_loss     )

						# dump tests result into json file to share in PR
						with open(F"""{estimator.latest_training_job.name}.json"""       ,			"""w"""     ) as outfile:
							json.dump({"""train_time""": train_runtime, """eval_accuracy""": eval_accuracy, """eval_loss""": eval_loss}       ,			A__     )



