
"""simple docstring"""





import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

_a									=				logging.get_logger(__name__)







def       __a	(						__lowerCamelCase,						__lowerCamelCase = True    ):
   UpperCAmelCase_   :   Tuple     	=       {}
   for name in model.attn_processors.keys():
      UpperCAmelCase_   :   Optional[Any]     	=       name.endswith("attn2.processor"    ) and not (
          name.startswith("transformer_in"    ) or "temp_attentions" in name.split("."    )
      )
      UpperCAmelCase_   :   List[Any]     	=       model.config.cross_attention_dim if has_cross_attention else None
      if name.startswith("mid_block"    ):
         UpperCAmelCase_   :   int     	=       model.config.block_out_channels[-1]
      elif name.startswith("up_blocks"    ):
         UpperCAmelCase_   :   int     	=       int(name[len("up_blocks."    )]    )
         UpperCAmelCase_   :   Optional[int]     	=       list(reversed(model.config.block_out_channels    )    )[block_id]
      elif name.startswith("down_blocks"    ):
         UpperCAmelCase_   :   str     	=       int(name[len("down_blocks."    )]    )
         UpperCAmelCase_   :   Tuple     	=       model.config.block_out_channels[block_id]
      elif name.startswith("transformer_in"    ):
         # Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
         UpperCAmelCase_   :   Optional[Any]     	=       8 * model.config.attention_head_dim

      UpperCAmelCase_   :   Dict     	=       LoRAAttnProcessor(hidden_size=__lowerCamelCase,						cross_attention_dim=__lowerCamelCase    )
      UpperCAmelCase_   :   Tuple     	=       lora_attn_procs[name].to(model.device    )

      if mock_weights:
         # add 1 to weights to mock trained weights
         with torch.no_grad():
            lora_attn_procs[name].to_q_lora.up.weight += 1
            lora_attn_procs[name].to_k_lora.up.weight += 1
            lora_attn_procs[name].to_v_lora.up.weight += 1
            lora_attn_procs[name].to_out_lora.up.weight += 1

   return lora_attn_procs


@skip_mps
class A_      (lowercase__							,lowercase__							,unittest.TestCase ):




  '''simple docstring'''
  SCREAMING_SNAKE_CASE__     :		Tuple    	=						UNetaDConditionModel
  SCREAMING_SNAKE_CASE__     :		Optional[int]    	=						"""sample"""







  @property
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Tuple     	=       4
     UpperCAmelCase_   :   Dict     	=       4
     UpperCAmelCase_   :   int     	=       4
     UpperCAmelCase_   :   Union[str, Any]     	=       (32, 32)

     UpperCAmelCase_   :   Any     	=       floats_tensor((batch_size, num_channels, num_frames) + sizes    ).to(lowercase_    )
     UpperCAmelCase_   :   int     	=       torch.tensor([10]    ).to(lowercase_    )
     UpperCAmelCase_   :   List[str]     	=       floats_tensor((batch_size, 4, 32)    ).to(lowercase_    )

     return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}







  @property
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return (4, 4, 32, 32)







  @property
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     return (4, 4, 32, 32)







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_   :   Union[str, Any]     	=       {
         "block_out_channels": (32, 64),
         "down_block_types": (
             "CrossAttnDownBlock3D",
             "DownBlock3D",
         ),
         "up_block_types": ("UpBlock3D", "CrossAttnUpBlock3D"),
         "cross_attention_dim": 32,
         "attention_head_dim": 8,
         "out_channels": 4,
         "in_channels": 4,
         "layers_per_block": 1,
         "sample_size": 32,
     }
     UpperCAmelCase_   :   int     	=       self.dummy_input
     return init_dict, inputs_dict







  @unittest.skipIf(
      torch_device != "cuda" or not is_xformers_available()							,  reason="XFormers attention is only available with CUDA and `xformers` installed"							,  )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[int]     	=       self.prepare_init_args_and_inputs_for_common()
     UpperCAmelCase_   :   List[str]     	=       self.model_class(**lowercase_    )

     model.enable_xformers_memory_efficient_attention()

     assert (
         model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
         == "XFormersAttnProcessor"
     ), "xformers is not enabled"







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   Tuple     	=       32

     UpperCAmelCase_   :   List[str]     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )
     model.eval()

     with torch.no_grad():
        UpperCAmelCase_   :   List[Any]     	=       model(**lowercase_    )

        if isinstance(lowercase_							,  lowercase_    ):
           UpperCAmelCase_   :   List[str]     	=       output.sample

     self.assertIsNotNone(lowercase_    )
     UpperCAmelCase_   :   Tuple     	=       inputs_dict["sample"].shape
     self.assertEqual(output.shape							,  lowercase_							,  "Input and output shapes do not match"    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()
     UpperCAmelCase_   :   List[Any]     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )
     model.eval()

     with torch.no_grad():
        # Warmup pass when using mps (see #372)
        if torch_device == "mps" and isinstance(lowercase_							,  lowercase_    ):
           model(**self.dummy_input    )

        UpperCAmelCase_   :   Union[str, Any]     	=       model(**lowercase_    )
        if isinstance(lowercase_							,  lowercase_    ):
           UpperCAmelCase_   :   Tuple     	=       first.sample

        UpperCAmelCase_   :   List[str]     	=       model(**lowercase_    )
        if isinstance(lowercase_							,  lowercase_    ):
           UpperCAmelCase_   :   Dict     	=       second.sample

     UpperCAmelCase_   :   List[str]     	=       first.cpu().numpy()
     UpperCAmelCase_   :   Optional[int]     	=       second.cpu().numpy()
     UpperCAmelCase_   :   int     	=       out_a[~np.isnan(lowercase_    )]
     UpperCAmelCase_   :   List[str]     	=       out_a[~np.isnan(lowercase_    )]
     UpperCAmelCase_   :   Optional[int]     	=       np.amax(np.abs(out_a - out_a    )    )
     self.assertLessEqual(lowercase_							,  1E-5    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Tuple     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   Tuple     	=       8

     UpperCAmelCase_   :   Optional[Any]     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )
     model.eval()

     model.set_attention_slice("auto"    )
     with torch.no_grad():
        UpperCAmelCase_   :   List[Any]     	=       model(**lowercase_    )
     assert output is not None

     model.set_attention_slice("max"    )
     with torch.no_grad():
        UpperCAmelCase_   :   List[Any]     	=       model(**lowercase_    )
     assert output is not None

     model.set_attention_slice(2    )
     with torch.no_grad():
        UpperCAmelCase_   :   Union[str, Any]     	=       model(**lowercase_    )
     assert output is not None







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[int]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   Optional[int]     	=       8

     UpperCAmelCase_   :   str     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Tuple     	=       model(**lowercase_    ).sample

     UpperCAmelCase_   :   int     	=       create_lora_layers(lowercase_    )

     # make sure we can set a list of attention processors
     model.set_attn_processor(lowercase_    )
     model.to(lowercase_    )

     # test that attn processors can be set to itself
     model.set_attn_processor(model.attn_processors    )

     with torch.no_grad():
        UpperCAmelCase_   :   List[Any]     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.0}    ).sample
        UpperCAmelCase_   :   str     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample
        UpperCAmelCase_   :   List[Any]     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample

     assert (samplea - samplea).abs().max() < 3E-3
     assert (samplea - samplea).abs().max() < 3E-3

     # sample 2 and sample 3 should be different
     assert (samplea - samplea).abs().max() > 3E-3







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   str     	=       8

     torch.manual_seed(0    )
     UpperCAmelCase_   :   int     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Any     	=       model(**lowercase_    ).sample

     UpperCAmelCase_   :   Optional[int]     	=       create_lora_layers(lowercase_    )
     model.set_attn_processor(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Tuple     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample

     with tempfile.TemporaryDirectory() as tmpdirname:
        model.save_attn_procs(lowercase_    )
        self.assertTrue(os.path.isfile(os.path.join(lowercase_							,  "pytorch_lora_weights.bin"    )    )    )
        torch.manual_seed(0    )
        UpperCAmelCase_   :   List[Any]     	=       self.model_class(**lowercase_    )
        new_model.to(lowercase_    )
        new_model.load_attn_procs(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Union[str, Any]     	=       new_model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample

     assert (sample - new_sample).abs().max() < 1E-3

     # LoRA and no LoRA should NOT be the same
     assert (sample - old_sample).abs().max() > 1E-4







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   List[str]     	=       8

     torch.manual_seed(0    )
     UpperCAmelCase_   :   int     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Any     	=       model(**lowercase_    ).sample

     UpperCAmelCase_   :   Tuple     	=       create_lora_layers(lowercase_    )
     model.set_attn_processor(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Tuple     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample

     with tempfile.TemporaryDirectory() as tmpdirname:
        model.save_attn_procs(lowercase_							,  safe_serialization=lowercase_    )
        self.assertTrue(os.path.isfile(os.path.join(lowercase_							,  "pytorch_lora_weights.safetensors"    )    )    )
        torch.manual_seed(0    )
        UpperCAmelCase_   :   Dict     	=       self.model_class(**lowercase_    )
        new_model.to(lowercase_    )
        new_model.load_attn_procs(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   Optional[Any]     	=       new_model(**lowercase_							,  cross_attention_kwargs={"scale": 0.5}    ).sample

     assert (sample - new_sample).abs().max() < 3E-3

     # LoRA and no LoRA should NOT be the same
     assert (sample - old_sample).abs().max() > 1E-4







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     # enable deterministic behavior for gradient checkpointing
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   Optional[int]     	=       8

     torch.manual_seed(0    )
     UpperCAmelCase_   :   Dict     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     UpperCAmelCase_   :   str     	=       create_lora_layers(lowercase_							,  mock_weights=lowercase_    )
     model.set_attn_processor(lowercase_    )
     # Saving as torch, properly reloads with directly filename
     with tempfile.TemporaryDirectory() as tmpdirname:
        model.save_attn_procs(lowercase_    )
        self.assertTrue(os.path.isfile(os.path.join(lowercase_							,  "pytorch_lora_weights.bin"    )    )    )
        torch.manual_seed(0    )
        UpperCAmelCase_   :   Dict     	=       self.model_class(**lowercase_    )
        new_model.to(lowercase_    )
        new_model.load_attn_procs(lowercase_							,  weight_name="pytorch_lora_weights.bin"    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   str     	=       8

     torch.manual_seed(0    )
     UpperCAmelCase_   :   List[Any]     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     UpperCAmelCase_   :   Tuple     	=       create_lora_layers(lowercase_							,  mock_weights=lowercase_    )
     model.set_attn_processor(lowercase_    )
     # Saving as torch, properly reloads with directly filename
     with tempfile.TemporaryDirectory() as tmpdirname:
        model.save_attn_procs(lowercase_    )
        self.assertTrue(os.path.isfile(os.path.join(lowercase_							,  "pytorch_lora_weights.bin"    )    )    )
        torch.manual_seed(0    )
        UpperCAmelCase_   :   int     	=       self.model_class(**lowercase_    )
        new_model.to(lowercase_    )
        with self.assertRaises(lowercase_    ) as e:
           new_model.load_attn_procs(lowercase_							,  use_safetensors=lowercase_    )
        self.assertIn("Error no file named pytorch_lora_weights.safetensors"							,  str(e.exception    )    )







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   List[Any]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   List[Any]     	=       8

     torch.manual_seed(0    )
     UpperCAmelCase_   :   str     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   str     	=       model(**lowercase_    ).sample

     UpperCAmelCase_   :   Any     	=       create_lora_layers(lowercase_    )
     model.set_attn_processor(lowercase_    )

     with torch.no_grad():
        UpperCAmelCase_   :   str     	=       model(**lowercase_							,  cross_attention_kwargs={"scale": 0.0}    ).sample

     model.set_attn_processor(AttnProcessor()    )

     with torch.no_grad():
        UpperCAmelCase_   :   Optional[Any]     	=       model(**lowercase_    ).sample

     assert (sample - new_sample).abs().max() < 1E-4
     assert (sample - old_sample).abs().max() < 3E-3







  @unittest.skipIf(
      torch_device != "cuda" or not is_xformers_available()							,  reason="XFormers attention is only available with CUDA and `xformers` installed"							,  )
  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     # enable deterministic behavior for gradient checkpointing
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[int]     	=       self.prepare_init_args_and_inputs_for_common()

     UpperCAmelCase_   :   List[str]     	=       4

     torch.manual_seed(0    )
     UpperCAmelCase_   :   Any     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )
     UpperCAmelCase_   :   int     	=       create_lora_layers(lowercase_    )
     model.set_attn_processor(lowercase_    )

     # default
     with torch.no_grad():
        UpperCAmelCase_   :   Dict     	=       model(**lowercase_    ).sample

        model.enable_xformers_memory_efficient_attention()
        UpperCAmelCase_   :   Tuple     	=       model(**lowercase_    ).sample

        model.disable_xformers_memory_efficient_attention()
        UpperCAmelCase_   :   Tuple     	=       model(**lowercase_    ).sample

     assert (sample - on_sample).abs().max() < 1E-4
     assert (sample - off_sample).abs().max() < 1E-4







  def 			UpperCamelCase__   (						self    ):

     """simple docstring"""
     UpperCAmelCase_	,  UpperCAmelCase_   :   Optional[Any]     	=       self.prepare_init_args_and_inputs_for_common()
     UpperCAmelCase_   :   Optional[int]     	=       32

     UpperCAmelCase_   :   str     	=       self.model_class(**lowercase_    )
     model.to(lowercase_    )
     model.eval()

     with torch.no_grad():
        UpperCAmelCase_   :   Optional[Any]     	=       model(**lowercase_    )[0]

     model.enable_forward_chunking()
     with torch.no_grad():
        UpperCAmelCase_   :   Optional[Any]     	=       model(**lowercase_    )[0]

     self.assertEqual(output.shape							,  output_a.shape							,  "Shape doesn't match"    )
     assert np.abs(output.cpu() - output_a.cpu()    ).max() < 1E-2


# (todo: sayakpaul) implement SLOW tests.




import unittest
from functools import partial

import torch

from accelerate import Accelerator, debug_launcher
from accelerate.state import AcceleratorState, GradientState
from accelerate.test_utils import require_cpu, require_huggingface_suite
from accelerate.utils import GradientAccumulationPlugin

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Any=2				,    __UpperCamelCase			:    str=True				,    __UpperCamelCase			:    Optional[Any]=False							)			->							Union[str, Any]:

				"""simple docstring"""







				A__	:						List[str]								=				Accelerator(step_scheduler_with_optimizer=__UpperCamelCase				,    split_batches=__UpperCamelCase							)
				A__	:						str								=				torch.nn.Linear(2				,    4							)
				A__	:						Any								=				torch.optim.AdamW(model.parameters()				,    lr=1.0							)
				A__	:						Tuple								=				torch.optim.lr_scheduler.OneCycleLR(__UpperCamelCase				,    max_lr=0.0_1				,    steps_per_epoch=2				,    epochs=1							)
				A__							,				A__							,				A__	:						str								=				accelerator.prepare(__UpperCamelCase				,    __UpperCamelCase				,    __UpperCamelCase							)

				# Optimizer has stepped
				scheduler.step()
				if step_scheduler_with_optimizer or (num_processes == 1):
								assert (
								    scheduler.scheduler.last_epoch == num_processes
								), F"Last Epoch ({scheduler.scheduler.last_epoch}) != Num Processes ({num_processes})"
				else:
								assert (
								    scheduler.scheduler.last_epoch != num_processes
								), F"Last Epoch ({scheduler.scheduler.last_epoch}) == Num Processes ({num_processes})"

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    Optional[Any]=2				,    __UpperCamelCase			:    Tuple=True				,    __UpperCamelCase			:    List[Any]=False							)			->							str:

				"""simple docstring"""







				A__	:						Union[str, Any]								=				Accelerator(step_scheduler_with_optimizer=__UpperCamelCase				,    split_batches=__UpperCamelCase							)
				A__	:						List[str]								=				torch.nn.Linear(2				,    4							)
				A__	:						int								=				torch.optim.AdamW(model.parameters()				,    lr=1.0							)
				A__	:						List[Any]								=				torch.optim.lr_scheduler.LambdaLR(__UpperCamelCase				,    lr_lambda=lambda __UpperCamelCase							: 1 - n / 10							)
				A__							,				A__							,				A__	:						int								=				accelerator.prepare(__UpperCamelCase				,    __UpperCamelCase				,    __UpperCamelCase							)

				# Optimizer has stepped
				A__	:						List[Any]								=				False
				scheduler.step()
				A__	:						str								=				1 - (num_processes if (step_scheduler_with_optimizer and not split_batches) else 1) / 10
				assert (
				    scheduler.get_last_lr()[0] == expected_lr
				), F"Wrong lr found at first step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}"

				# Optimizer has not stepped
				A__	:						str								=				True
				scheduler.step()
				if not step_scheduler_with_optimizer:
								A__	:						Dict								=				1 - 2 / 10
				assert (
				    scheduler.get_last_lr()[0] == expected_lr
				), F"Wrong lr found at second step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}"

def 					SCREAMING_SNAKE_CASE  (   __UpperCamelCase			:    int = 2							)			->							List[Any]:

				"""simple docstring"""







				from transformers import get_linear_schedule_with_warmup

				A__	:						str								=				[1, 2, 4]
				for num_steps in steps:
								A__	:						Any								=				GradientAccumulationPlugin(num_steps=__UpperCamelCase				,    adjust_scheduler=num_steps > 1							)
								A__	:						Tuple								=				Accelerator(gradient_accumulation_plugin=__UpperCamelCase							)
								A__	:						Optional[int]								=				torch.nn.Linear(2				,    4							)
								A__	:						Optional[int]								=				torch.optim.AdamW(model.parameters()				,    lr=1_0.0							)
								A__	:						Optional[int]								=				get_linear_schedule_with_warmup(optimizer=__UpperCamelCase				,    num_warmup_steps=0				,    num_training_steps=20							)

								A__							,				A__							,				A__	:						List[Any]								=				accelerator.prepare(__UpperCamelCase				,    __UpperCamelCase				,    __UpperCamelCase							)

								for i in range(10 * num_steps							):
												with accelerator.accumulate(__UpperCamelCase							):
																optimizer.step()
																scheduler.step()

												if i == (10 * num_steps - 2):
																assert (
																    scheduler.get_last_lr()[0] != 0
																), F"Wrong lr found at second-to-last step, expected non-zero, got {scheduler.get_last_lr()[0]}. num_steps: {num_steps}"
								assert (
								    scheduler.get_last_lr()[0] == 0
								), F"Wrong lr found at last step, expected 0, got {scheduler.get_last_lr()[0]}"
								GradientState._reset_state()







@require_cpu
class 			UpperCamelCase__		(     unittest.TestCase ):







	'''simple docstring'''





	def 	__snake_case					(      self		):
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1		)					,							num_processes=1		)
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							split_batches=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1		)					,							num_processes=1		)
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							split_batches=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							step_scheduler_with_optimizer=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							step_scheduler_with_optimizer=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					AcceleratorState._reset_state(UpperCamelCase__		)
					debug_launcher(UpperCamelCase__		)
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							split_batches=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					AcceleratorState._reset_state(UpperCamelCase__		)
					debug_launcher(UpperCamelCase__		)
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1					,							split_batches=UpperCamelCase__		)					,							num_processes=1		)





	def 	__snake_case					(      self		):
					AcceleratorState._reset_state(UpperCamelCase__		)
					debug_launcher(partial(UpperCamelCase__					,							step_scheduler_with_optimizer=UpperCamelCase__		)		)





	def 	__snake_case					(      self		):
					AcceleratorState._reset_state(UpperCamelCase__		)
					debug_launcher(partial(UpperCamelCase__					,							step_scheduler_with_optimizer=UpperCamelCase__		)		)





	@require_huggingface_suite
	def 	__snake_case					(      self		):
					AcceleratorState._reset_state(UpperCamelCase__		)
					debug_launcher(partial(UpperCamelCase__					,							num_processes=1		)		)
					debug_launcher(UpperCamelCase__		)