






import os

import pytest
from attr import dataclass


__UpperCAmelCase								=						'us-east-1'  # defaults region



@dataclass
class   lowerCamelCase      :







		'''simple docstring'''



		_snake_case    :    str
		_snake_case    :    List[Any]       						=  '''arn:aws:iam::558105141721:role/sagemaker_execution_role'''
		_snake_case    :    Any       						=  {
		    '''task_name''': '''mnli''',
		    '''per_device_train_batch_size''': 1_6,
		    '''per_device_eval_batch_size''': 1_6,
		    '''do_train''': True,
		    '''do_eval''': True,
		    '''do_predict''': True,
		    '''output_dir''': '''/opt/ml/model''',
		    '''overwrite_output_dir''': True,
		    '''max_steps''': 5_0_0,
		    '''save_steps''': 5_5_0_0,
		}
		_snake_case    :    Tuple       						=  {**hyperparameters, '''max_steps''': 1_0_0_0}



		@property
		def 					__UpperCAmelCase			(							self   )	->							str:
							if self.framework == "pytorch":
												return [
												    {"Name": "train_runtime", "Regex": r"train_runtime.*=\D*(.*?)$"},
												    {"Name": "eval_accuracy", "Regex": r"eval_accuracy.*=\D*(.*?)$"},
												    {"Name": "eval_loss", "Regex": r"eval_loss.*=\D*(.*?)$"},
												]
							else:
												return [
												    {"Name": "train_runtime", "Regex": r"train_runtime.*=\D*(.*?)$"},
												    {"Name": "eval_accuracy", "Regex": r"loss.*=\D*(.*?)]?$"},
												    {"Name": "eval_loss", "Regex": r"sparse_categorical_accuracy.*=\D*(.*?)]?$"},
												]



		@property
		def 					__UpperCAmelCase			(							self   )	->							str:
							return f"{self.framework}-transfromers-test"



		@property
		def 					__UpperCAmelCase			(							self   )	->							str:
							return f"./tests/sagemaker/scripts/{self.framework}"



		@property
		def 					__UpperCAmelCase			(							self   )	->							str:
							if self.framework == "pytorch":
												return "763104351884.dkr.ecr.us-east-1.amazonaws.com/huggingface-pytorch-training:1.7.1-transformers4.6.1-gpu-py36-cu110-ubuntu18.04"
							else:
												return "763104351884.dkr.ecr.us-east-1.amazonaws.com/huggingface-tensorflow-training:2.4.1-transformers4.6.1-gpu-py37-cu110-ubuntu18.04"





@pytest.fixture(scope='class'  )
def      lowercase__      (     __snake_case    :							Tuple  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Any            =						SageMakerTestEnvironment(framework=request.cls.framework  )














import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class   lowerCamelCase      (_snake_case ,  _snake_case ,  unittest.TestCase			):







		'''simple docstring'''



		_snake_case    :    Union[str, Any]       						=  IFImgaImgSuperResolutionPipeline
		_snake_case    :    Union[str, Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'''width''', '''height'''}
		_snake_case    :    List[Any]       						=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''original_image'''}			)
		_snake_case    :    List[str]       						=  PipelineTesterMixin.required_optional_params - {'''latents'''}



		def 					__UpperCAmelCase			(							self   )	->							Optional[Any]:
							return self._get_superresolution_dummy_components()



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase				,		_UpperCamelCase=0   )	->							Any:
							if str(_UpperCamelCase   ).startswith('mps'   ):
												UpperCAmelCase_    :      List[Any]            =						torch.manual_seed(_UpperCamelCase   )
							else:
												UpperCAmelCase_    :      int            =						torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )

							UpperCAmelCase_    :      List[Any]            =						floats_tensor((1, 3, 3_2, 3_2)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
							UpperCAmelCase_    :      Dict            =						floats_tensor((1, 3, 1_6, 1_6)				,		rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

							UpperCAmelCase_    :      Tuple            =						{
							    'prompt': 'A painting of a squirrel eating a burger',
							    'image': image,
							    'original_image': original_image,
							    'generator': generator,
							    'num_inference_steps': 2,
							    'output_type': 'numpy',
							}

							return inputs



		@unittest.skipIf(
		    torch_device != 'cuda' or not is_xformers_available()				,		reason='XFormers attention is only available with CUDA and `xformers` installed'				,		)
		def 					__UpperCAmelCase			(							self   )	->							Any:
							self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_save_load_optional_components()



		@unittest.skipIf(torch_device != 'cuda'				,		reason='float16 requires CUDA'   )
		def 					__UpperCAmelCase			(							self   )	->							str:
							# Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
							super().test_save_load_floataa(expected_max_diff=1E-1   )



		def 					__UpperCAmelCase			(							self   )	->							List[Any]:
							self._test_attention_slicing_forward_pass(expected_max_diff=1E-2   )



		def 					__UpperCAmelCase			(							self   )	->							Union[str, Any]:
							self._test_save_load_local()



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							self._test_inference_batch_single_identical(
							    expected_max_diff=1E-2				,		)






