



import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class       _SCREAMING_SNAKE_CASE	(UpperCamelCase			,    unittest.TestCase ):
     lowerCAmelCase					=			DiTPipeline
     lowerCAmelCase					=			CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
     lowerCAmelCase					=			PipelineTesterMixin.required_optional_params - {
         """latents""",
         """num_images_per_prompt""",
         """callback""",
         """callback_steps""",
     }
     lowerCAmelCase					=			CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
     lowerCAmelCase					=			False





     def 	__snake_case    (       self :							Tuple				)->Any:
      torch.manual_seed(0				)
      __SCREAMING_SNAKE_CASE       :    Tuple       =	TransformeraDModel(
          sample_size=1_6     ,  num_layers=2     ,  patch_size=4     ,  attention_head_dim=8     ,  num_attention_heads=2     ,  in_channels=4     ,  out_channels=8     ,  attention_bias=UpperCamelCase     ,  activation_fn="gelu-approximate"     ,  num_embeds_ada_norm=1_0_0_0     ,  norm_type="ada_norm_zero"     ,  norm_elementwise_affine=UpperCamelCase     ,  )
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	AutoencoderKL()
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	DDIMScheduler()
      __SCREAMING_SNAKE_CASE       :    Dict       =	{"transformer": transformer.eval(), "vae": vae.eval(), "scheduler": scheduler}
      return components





     def 	__snake_case    (       self :							int     ,  UpperCamelCase :							Dict     ,  UpperCamelCase :							Union[str, Any]=0				)->Any:
      if str(UpperCamelCase				).startswith("mps"				):
       __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	torch.manual_seed(UpperCamelCase				)
      else:
       __SCREAMING_SNAKE_CASE       :    Any       =	torch.Generator(device=UpperCamelCase				).manual_seed(UpperCamelCase				)
      __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	{
          "class_labels": [1],
          "generator": generator,
          "num_inference_steps": 2,
          "output_type": "numpy",
      }
      return inputs





     def 	__snake_case    (       self :							Dict				)->List[str]:
      __SCREAMING_SNAKE_CASE       :    Dict       =	"cpu"

      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	self.get_dummy_components()
      __SCREAMING_SNAKE_CASE       :    str       =	self.pipeline_class(**UpperCamelCase				)
      pipe.to(UpperCamelCase				)
      pipe.set_progress_bar_config(disable=UpperCamelCase				)

      __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	self.get_dummy_inputs(UpperCamelCase				)
      __SCREAMING_SNAKE_CASE       :    Optional[int]       =	pipe(**UpperCamelCase				).images
      __SCREAMING_SNAKE_CASE       :    List[str]       =	image[0, -3:, -3:, -1]

      self.assertEqual(image.shape     ,  (1, 1_6, 1_6, 3)				)
      __SCREAMING_SNAKE_CASE       :    Dict       =	np.array([0.2_9_4_6, 0.6_6_0_1, 0.4_3_2_9, 0.3_2_9_6, 0.4_1_4_4, 0.5_3_1_9, 0.7_2_7_3, 0.5_0_1_3, 0.4_4_5_7]				)
      __SCREAMING_SNAKE_CASE       :    List[str]       =	np.abs(image_slice.flatten() - expected_slice				).max()
      self.assertLessEqual(UpperCamelCase     ,  1E-3				)





     def 	__snake_case    (       self :							List[Any]				)->Dict:
      self._test_inference_batch_single_identical(relax_max_difference=UpperCamelCase     ,  expected_max_diff=1E-3				)






     @unittest.skipIf(
         torch_device != "cuda" or not is_xformers_available()     ,  reason="XFormers attention is only available with CUDA and `xformers` installed"     ,  )
     def 	__snake_case    (       self :							Optional[int]				)->Dict:
      self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3				)






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





     def 	__snake_case    (       self :							List[Any]				)->Dict:
      super().tearDown()
      gc.collect()
      torch.cuda.empty_cache()





     def 	__snake_case    (       self :							Dict				)->List[str]:
      __SCREAMING_SNAKE_CASE       :    str       =	torch.manual_seed(0				)

      __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	DiTPipeline.from_pretrained("facebook/DiT-XL-2-256"				)
      pipe.to("cuda"				)

      __SCREAMING_SNAKE_CASE       :    List[str]       =	["vase", "umbrella", "white shark", "white wolf"]
      __SCREAMING_SNAKE_CASE       :    int       =	pipe.get_label_ids(UpperCamelCase				)

      __SCREAMING_SNAKE_CASE       :    List[str]       =	pipe(UpperCamelCase     ,  generator=UpperCamelCase     ,  num_inference_steps=4_0     ,  output_type="np"				).images

      for word, image in zip(UpperCamelCase     ,  UpperCamelCase				):
       __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	load_numpy(
           F"""https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy"""				)
       assert np.abs((expected_image - image).max()				) < 1E-2






     def 	__snake_case    (       self :							Union[str, Any]				)->Optional[Any]:
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	DiTPipeline.from_pretrained("facebook/DiT-XL-2-512"				)
      __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
      pipe.to("cuda"				)

      __SCREAMING_SNAKE_CASE       :    List[Any]       =	["vase", "umbrella"]
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	pipe.get_label_ids(UpperCamelCase				)

      __SCREAMING_SNAKE_CASE       :    str       =	torch.manual_seed(0				)
      __SCREAMING_SNAKE_CASE       :    List[Any]       =	pipe(UpperCamelCase     ,  generator=UpperCamelCase     ,  num_inference_steps=2_5     ,  output_type="np"				).images

      for word, image in zip(UpperCamelCase     ,  UpperCamelCase				):
       __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	load_numpy(
           "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
           F"""/dit/{word}_512.npy"""				)

       assert np.abs((expected_image - image).max()				) < 1E-1











# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import json
import os

from ...utils.constants import SAGEMAKER_PARALLEL_EC2_INSTANCES, TORCH_DYNAMO_MODES
from ...utils.dataclasses import ComputeEnvironment, SageMakerDistributedType
from ...utils.imports import is_botoa_available
from .config_args import SageMakerConfig
from .config_utils import (
    DYNAMO_BACKENDS,
    _ask_field,
    _ask_options,
    _convert_dynamo_backend,
    _convert_mixed_precision,
    _convert_sagemaker_distributed_mode,
    _convert_yes_no_to_bool,
)


if is_botoa_available():
      import botoa  # noqa: F401






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Optional[int]     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	botoa.client("iam"     )

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	{
     "Version": "2012-10-17",
     "Statement": [
         {"Effect": "Allow", "Principal": {"Service": "sagemaker.amazonaws.com"}, "Action": "sts:AssumeRole"}
     ],
 }
 try:
  # create the role, associated with the chosen trust policy
  iam_client.create_role(
      RoleName=__lowerCamelCase		,	AssumeRolePolicyDocument=json.dumps(__lowerCamelCase		,	indent=2     )     )
  __SCREAMING_SNAKE_CASE       :    str       =	{
      "Version": "2012-10-17",
      "Statement": [
          {
              "Effect": "Allow",
              "Action": [
                  "sagemaker:*",
                  "ecr:GetDownloadUrlForLayer",
                  "ecr:BatchGetImage",
                  "ecr:BatchCheckLayerAvailability",
                  "ecr:GetAuthorizationToken",
                  "cloudwatch:PutMetricData",
                  "cloudwatch:GetMetricData",
                  "cloudwatch:GetMetricStatistics",
                  "cloudwatch:ListMetrics",
                  "logs:CreateLogGroup",
                  "logs:CreateLogStream",
                  "logs:DescribeLogStreams",
                  "logs:PutLogEvents",
                  "logs:GetLogEvents",
                  "s3:CreateBucket",
                  "s3:ListBucket",
                  "s3:GetBucketLocation",
                  "s3:GetObject",
                  "s3:PutObject",
              ],
              "Resource": "*",
          }
      ],
  }
  # attach policy to role
  iam_client.put_role_policy(
      RoleName=__lowerCamelCase		,	PolicyName=F"""{role_name}_policy_permission"""		,	PolicyDocument=json.dumps(__lowerCamelCase		,	indent=2     )		,	)
 except iam_client.exceptions.EntityAlreadyExistsException:
  print(F"""role {role_name} already exists. Using existing one"""     )






def 	_lowerCAmelCase						(				__lowerCamelCase   :     Dict     ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    List[str]       =	botoa.client("iam"     )
 return iam_client.get_role(RoleName=__lowerCamelCase     )["Role"]["Arn"]






def 	_lowerCAmelCase						(				):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE       :    Any       =	_ask_options(
     "How do you want to authorize?"		,	["AWS Profile", "Credentials (AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY) "]		,	__lowerCamelCase		,	)
 __SCREAMING_SNAKE_CASE       :    str       =	None
 if credentials_configuration == 0:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	_ask_field("Enter your AWS Profile name: [default] "		,	default="default"     )
  __SCREAMING_SNAKE_CASE       :    Any       =	aws_profile
 else:
  print(
      "Note you will need to provide AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY when you launch you training script with,"
      "`accelerate launch --aws_access_key_id XXX --aws_secret_access_key YYY`"     )
  __SCREAMING_SNAKE_CASE       :    Dict       =	_ask_field("AWS Access Key ID: "     )
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	aws_access_key_id

  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_field("AWS Secret Access Key: "     )
  __SCREAMING_SNAKE_CASE       :    Optional[int]       =	aws_secret_access_key

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	_ask_field("Enter your AWS Region: [us-east-1]"		,	default="us-east-1"     )
 __SCREAMING_SNAKE_CASE       :    Any       =	aws_region

 __SCREAMING_SNAKE_CASE       :    int       =	_ask_options(
     "Do you already have an IAM Role for executing Amazon SageMaker Training Jobs?"		,	["Provide IAM Role name", "Create new IAM role using credentials"]		,	__lowerCamelCase		,	)
 if role_management == 0:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	_ask_field("Enter your IAM role name: "     )
 else:
  __SCREAMING_SNAKE_CASE       :    Any       =	"accelerate_sagemaker_execution_role"
  print(F"""Accelerate will create an iam role \"{iam_role_name}\" using the provided credentials"""     )
  _create_iam_role_for_sagemaker(__lowerCamelCase     )

 __SCREAMING_SNAKE_CASE       :    Any       =	_ask_field(
     "Do you want to use custom Docker image? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
 __SCREAMING_SNAKE_CASE       :    Tuple       =	None
 if is_custom_docker_image:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	_ask_field("Enter your Docker image: "		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()     )

 __SCREAMING_SNAKE_CASE       :    Dict       =	_ask_field(
     "Do you want to provide SageMaker input channels with data locations? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
 __SCREAMING_SNAKE_CASE       :    List[Any]       =	None
 if is_sagemaker_inputs_enabled:
  __SCREAMING_SNAKE_CASE       :    List[str]       =	_ask_field(
      "Enter the path to the SageMaker inputs TSV file with columns (channel_name, data_location): "		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()		,	)

 __SCREAMING_SNAKE_CASE       :    Dict       =	_ask_field(
     "Do you want to enable SageMaker metrics? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
 __SCREAMING_SNAKE_CASE       :    int       =	None
 if is_sagemaker_metrics_enabled:
  __SCREAMING_SNAKE_CASE       :    Dict       =	_ask_field(
      "Enter the path to the SageMaker metrics TSV file with columns (metric_name, metric_regex): "		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()		,	)

 __SCREAMING_SNAKE_CASE       :    Any       =	_ask_options(
     "What is the distributed mode?"		,	["No distributed training", "Data parallelism"]		,	_convert_sagemaker_distributed_mode		,	)
 __SCREAMING_SNAKE_CASE       :    Tuple       =	{}
 __SCREAMING_SNAKE_CASE       :    str       =	_ask_field(
     "Do you wish to optimize your script with torch dynamo?[yes/NO]:"		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
 if use_dynamo:
  __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	"dynamo_"
  __SCREAMING_SNAKE_CASE       :    Optional[Any]       =	_ask_options(
      "Which dynamo backend would you like to use?"		,	[x.lower() for x in DYNAMO_BACKENDS]		,	_convert_dynamo_backend		,	default=2		,	)
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_field(
      "Do you want to customize the defaults sent to torch.compile? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)

  if use_custom_options:
   __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_options(
       "Which mode do you want to use?"		,	__lowerCamelCase		,	lambda __lowerCamelCase     : TORCH_DYNAMO_MODES[int(__lowerCamelCase     )]		,	default="default"		,	)
   __SCREAMING_SNAKE_CASE       :    str       =	_ask_field(
       "Do you want the fullgraph mode or it is ok to break model into several subgraphs? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
   __SCREAMING_SNAKE_CASE       :    Any       =	_ask_field(
       "Do you want to enable dynamic shape tracing? [yes/NO]: "		,	_convert_yes_no_to_bool		,	default=__lowerCamelCase		,	error_message="Please enter yes or no."		,	)
 __SCREAMING_SNAKE_CASE       :    Optional[int]       =	"Which EC2 instance type you want to use for your training?"
 if distributed_type != SageMakerDistributedType.NO:
  __SCREAMING_SNAKE_CASE       :    List[Any]       =	_ask_options(
      __lowerCamelCase		,	__lowerCamelCase		,	lambda __lowerCamelCase     : SAGEMAKER_PARALLEL_EC2_INSTANCES[int(__lowerCamelCase     )]     )
 else:
  eca_instance_query += "? [ml.p3.2xlarge]:"
  __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_field(__lowerCamelCase		,	lambda __lowerCamelCase     : str(__lowerCamelCase     ).lower()		,	default="ml.p3.2xlarge"     )

 __SCREAMING_SNAKE_CASE       :    List[Any]       =	1
 if distributed_type in (SageMakerDistributedType.DATA_PARALLEL, SageMakerDistributedType.MODEL_PARALLEL):
  __SCREAMING_SNAKE_CASE       :    Any       =	_ask_field(
      "How many machines do you want use? [1]: "		,	__lowerCamelCase		,	default=1		,	)

 __SCREAMING_SNAKE_CASE       :    Union[str, Any]       =	_ask_options(
     "Do you wish to use FP16 or BF16 (mixed precision)?"		,	["no", "fp16", "bf16", "fp8"]		,	_convert_mixed_precision		,	)

 if use_dynamo and mixed_precision == "no":
  print(
      "Torch dynamo used without mixed precision requires TF32 to be efficient. Accelerate will enable it by default when launching your scripts."     )

 return SageMakerConfig(
     image_uri=__lowerCamelCase		,	compute_environment=ComputeEnvironment.AMAZON_SAGEMAKER		,	distributed_type=__lowerCamelCase		,	use_cpu=__lowerCamelCase		,	dynamo_config=__lowerCamelCase		,	eca_instance_type=__lowerCamelCase		,	profile=__lowerCamelCase		,	region=__lowerCamelCase		,	iam_role_name=__lowerCamelCase		,	mixed_precision=__lowerCamelCase		,	num_machines=__lowerCamelCase		,	sagemaker_inputs_file=__lowerCamelCase		,	sagemaker_metrics_file=__lowerCamelCase		,	)






