



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  a				(     unittest.TestCase							):



		def       __lowerCamelCase     (	self	:Optional[int]    ):







						with tempfile.TemporaryDirectory() as tmpdirname:
										# pipeline has Flax weights
										snake_case__      : Union[str, Any]							=      FlaxDiffusionPipeline.from_pretrained(
										    '''hf-internal-testing/tiny-stable-diffusion-pipe'''  ,safety_checker=SCREAMING_SNAKE_CASE_  ,cache_dir=SCREAMING_SNAKE_CASE_    )

										snake_case__      : int							=      [t[-1] for t in os.walk(os.path.join(SCREAMING_SNAKE_CASE_  ,os.listdir(SCREAMING_SNAKE_CASE_    )[0]  ,'''snapshots'''    )    )]
										snake_case__      : Union[str, Any]							=      [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  a				(     unittest.TestCase							):



		def       __lowerCamelCase     (	self	:Tuple    ):
						snake_case__						,					snake_case__      : Dict							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''hf-internal-testing/tiny-stable-diffusion-pipe'''  ,safety_checker=SCREAMING_SNAKE_CASE_    )

						snake_case__      : List[str]							=      (
						    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
						    ''' field, close up, split lighting, cinematic'''
						)

						snake_case__      : Union[str, Any]							=      jax.random.PRNGKey(0    )
						snake_case__      : Optional[int]							=      4

						snake_case__      : Dict							=      jax.device_count()
						snake_case__      : Tuple							=      num_samples * [prompt]
						snake_case__      : Any							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )

						# shard inputs and rng
						snake_case__      : Optional[int]							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : List[str]							=      jax.random.split(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_    )
						snake_case__      : Optional[Any]							=      shard(SCREAMING_SNAKE_CASE_    )

						snake_case__      : Union[str, Any]							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images

						assert images.shape == (num_samples, 1, 6_4, 6_4, 3)
						if jax.device_count() == 8:
										assert np.abs(np.abs(images[0, 0, :2, :2, -2:]  ,dtype=np.floataa    ).sum() - 4.151_4745    ) < 1e-3
										assert np.abs(np.abs(SCREAMING_SNAKE_CASE_  ,dtype=np.floataa    ).sum() - 4_9_9_4_7.8_7_5    ) < 5e-1

						snake_case__      : List[Any]							=      pipeline.numpy_to_pil(np.asarray(images.reshape((num_samples,) + images.shape[-3:]    )    )    )
						assert len(SCREAMING_SNAKE_CASE_    ) == num_samples



		def       __lowerCamelCase     (	self	:List[Any]    ):
						snake_case__						,					snake_case__      : Optional[int]							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''flax'''  ,safety_checker=SCREAMING_SNAKE_CASE_    )

						snake_case__      : List[str]							=      (
						    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
						    ''' field, close up, split lighting, cinematic'''
						)

						snake_case__      : List[str]							=      jax.random.PRNGKey(0    )
						snake_case__      : Dict							=      5_0

						snake_case__      : Any							=      jax.device_count()
						snake_case__      : List[Any]							=      num_samples * [prompt]
						snake_case__      : Optional[int]							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )

						# shard inputs and rng
						snake_case__      : Optional[int]							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Optional[int]							=      jax.random.split(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_    )
						snake_case__      : Dict							=      shard(SCREAMING_SNAKE_CASE_    )

						snake_case__      : Dict							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images

						assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:]  ,dtype=np.floataa    ).sum() - 0.0565_2401)    ) < 1e-3
										assert np.abs((np.abs(SCREAMING_SNAKE_CASE_  ,dtype=np.floataa    ).sum() - 2_3_8_3_8_0_8.2)    ) < 5e-1



		def       __lowerCamelCase     (	self	:Optional[Any]    ):
						snake_case__						,					snake_case__      : List[Any]							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''bf16'''  ,dtype=jnp.bfloataa  ,safety_checker=SCREAMING_SNAKE_CASE_    )

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

						snake_case__      : Dict							=      jax.random.PRNGKey(0    )
						snake_case__      : Any							=      5_0

						snake_case__      : Tuple							=      jax.device_count()
						snake_case__      : List[str]							=      num_samples * [prompt]
						snake_case__      : Optional[Any]							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )

						# shard inputs and rng
						snake_case__      : str							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Dict							=      jax.random.split(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_    )
						snake_case__      : Optional[int]							=      shard(SCREAMING_SNAKE_CASE_    )

						snake_case__      : Optional[Any]							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images

						assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:]  ,dtype=np.floataa    ).sum() - 0.0400_3906)    ) < 1e-3
										assert np.abs((np.abs(SCREAMING_SNAKE_CASE_  ,dtype=np.floataa    ).sum() - 2_3_7_3_5_1_6.7_5)    ) < 5e-1



		def       __lowerCamelCase     (	self	:Optional[Any]    ):
						snake_case__						,					snake_case__      : int							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''bf16'''  ,dtype=jnp.bfloataa    )

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

						snake_case__      : Optional[Any]							=      jax.random.PRNGKey(0    )
						snake_case__      : str							=      5_0

						snake_case__      : Optional[Any]							=      jax.device_count()
						snake_case__      : Union[str, Any]							=      num_samples * [prompt]
						snake_case__      : Optional[int]							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )

						# shard inputs and rng
						snake_case__      : Optional[int]							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : List[str]							=      jax.random.split(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_    )
						snake_case__      : Any							=      shard(SCREAMING_SNAKE_CASE_    )

						snake_case__      : Union[str, Any]							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images

						assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:]  ,dtype=np.floataa    ).sum() - 0.0400_3906)    ) < 1e-3
										assert np.abs((np.abs(SCREAMING_SNAKE_CASE_  ,dtype=np.floataa    ).sum() - 2_3_7_3_5_1_6.7_5)    ) < 5e-1



		def       __lowerCamelCase     (	self	:Optional[int]    ):
						snake_case__      : Any							=      FlaxDDIMScheduler(
						    beta_start=0.0_0085  ,beta_end=0.012  ,beta_schedule='''scaled_linear'''  ,set_alpha_to_one=SCREAMING_SNAKE_CASE_  ,steps_offset=1  ,)

						snake_case__						,					snake_case__      : List[str]							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''bf16'''  ,dtype=jnp.bfloataa  ,scheduler=SCREAMING_SNAKE_CASE_  ,safety_checker=SCREAMING_SNAKE_CASE_  ,)
						snake_case__      : List[str]							=      scheduler.create_state()

						snake_case__      : str							=      scheduler_state

						snake_case__      : Union[str, Any]							=      (
						    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
						    ''' field, close up, split lighting, cinematic'''
						)

						snake_case__      : List[str]							=      jax.random.PRNGKey(0    )
						snake_case__      : Tuple							=      5_0

						snake_case__      : str							=      jax.device_count()
						snake_case__      : int							=      num_samples * [prompt]
						snake_case__      : Union[str, Any]							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )

						# shard inputs and rng
						snake_case__      : Optional[int]							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Union[str, Any]							=      jax.random.split(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_    )
						snake_case__      : str							=      shard(SCREAMING_SNAKE_CASE_    )

						snake_case__      : str							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images

						assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						if jax.device_count() == 8:
										assert np.abs((np.abs(images[0, 0, :2, :2, -2:]  ,dtype=np.floataa    ).sum() - 0.0_4504_3945)    ) < 1e-3
										assert np.abs((np.abs(SCREAMING_SNAKE_CASE_  ,dtype=np.floataa    ).sum() - 2_3_4_7_6_9_3.5)    ) < 5e-1






		def       __lowerCamelCase     (	self	:List[Any]    ):
						snake_case__      : List[Any]							=      (
						    '''A cinematic film still of Morgan Freeman starring as Jimi Hendrix, portrait, 40mm lens, shallow depth of'''
						    ''' field, close up, split lighting, cinematic'''
						)

						snake_case__      : Union[str, Any]							=      jax.device_count()
						snake_case__      : Any							=      num_samples * [prompt]
						snake_case__      : List[Any]							=      jax.random.split(jax.random.PRNGKey(0    )  ,SCREAMING_SNAKE_CASE_    )

						snake_case__						,					snake_case__      : Optional[int]							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''bf16'''  ,dtype=jnp.bfloataa  ,safety_checker=SCREAMING_SNAKE_CASE_  ,)

						snake_case__      : List[Any]							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Tuple							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Dict							=      shard(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Dict							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images
						assert images.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						snake_case__      : Union[str, Any]							=      images[2, 0, 2_5_6, 1_0:1_7, 1]

						# With memory efficient attention
						snake_case__						,					snake_case__      : Optional[int]							=      FlaxStableDiffusionPipeline.from_pretrained(
						    '''CompVis/stable-diffusion-v1-4'''  ,revision='''bf16'''  ,dtype=jnp.bfloataa  ,safety_checker=SCREAMING_SNAKE_CASE_  ,use_memory_efficient_attention=SCREAMING_SNAKE_CASE_  ,)

						snake_case__      : int							=      replicate(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Optional[Any]							=      pipeline.prepare_inputs(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Dict							=      shard(SCREAMING_SNAKE_CASE_    )
						snake_case__      : Union[str, Any]							=      pipeline(SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,SCREAMING_SNAKE_CASE_  ,jit=SCREAMING_SNAKE_CASE_    ).images
						assert images_eff.shape == (num_samples, 1, 5_1_2, 5_1_2, 3)
						snake_case__      : Tuple							=      images[2, 0, 2_5_6, 1_0:1_7, 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



"""simple docstring"""




import os

import torch

from ..logging import get_logger
from .constants import FSDP_PYTORCH_VERSION, MODEL_NAME, OPTIMIZER_NAME
from .versions import is_torch_version


if is_torch_version('>=', FSDP_PYTORCH_VERSION):
						import torch.distributed.checkpoint as dist_cp
						from torch.distributed.checkpoint.default_planner import DefaultLoadPlanner, DefaultSavePlanner
						from torch.distributed.checkpoint.optimizer import load_sharded_optimizer_state_dict
						from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel as FSDP
						from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType


lowerCAmelCase__				=					get_logger(__name__)



def 							_lowerCamelCase			(			__a,				__a,				__a,				__a,				__a=0     ):
		os.makedirs(__a,				exist_ok=__a     )
		with FSDP.state_dict_type(
		    __a,				fsdp_plugin.state_dict_type,				fsdp_plugin.state_dict_config,				fsdp_plugin.optim_state_dict_config     ):
				SCREAMING_SNAKE_CASE_    			=			model.state_dict()
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			F'{MODEL_NAME}.bin' if model_index == 0 else F'{MODEL_NAME}_{model_index}.bin'
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
						if accelerator.process_index == 0:
								logger.info(F'Saving model to {output_model_file}'     )
								torch.save(__a,				__a     )
								logger.info(F'Model saved to {output_model_file}'     )
				elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			(
						    F'{MODEL_NAME}_rank{accelerator.process_index}.bin'
						    if model_index == 0
						    else F'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
						)
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
						logger.info(F'Saving model to {output_model_file}'     )
						torch.save(__a,				__a     )
						logger.info(F'Model saved to {output_model_file}'     )
				elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				F'{MODEL_NAME}_{model_index}'     )
						os.makedirs(__a,				exist_ok=__a     )
						logger.info(F'Saving model to {ckpt_dir}'     )
						SCREAMING_SNAKE_CASE_    			=			{'''model''': state_dict}

						dist_cp.save_state_dict(
						    state_dict=__a,				storage_writer=dist_cp.FileSystemWriter(__a     ),				planner=DefaultSavePlanner(),				)
						logger.info(F'Model saved to {ckpt_dir}'     )



def 							_lowerCamelCase			(			__a,				__a,				__a,				__a,				__a=0     ):
		accelerator.wait_for_everyone()
		with FSDP.state_dict_type(
		    __a,				fsdp_plugin.state_dict_type,				fsdp_plugin.state_dict_config,				fsdp_plugin.optim_state_dict_config     ):
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						if type(__a     ) != FSDP and accelerator.process_index != 0:
								if not fsdp_plugin.sync_module_states:
										raise ValueError(
										    '''Set the `sync_module_states` flag to `True` so that model states are synced across processes when '''
										    '''initializing FSDP object'''     )
								return
						SCREAMING_SNAKE_CASE_    			=			F'{MODEL_NAME}.bin' if model_index == 0 else F'{MODEL_NAME}_{model_index}.bin'
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
						logger.info(F'Loading model from {input_model_file}'     )
						SCREAMING_SNAKE_CASE_    			=			torch.load(__a     )
						logger.info(F'Model loaded from {input_model_file}'     )
				elif fsdp_plugin.state_dict_type == StateDictType.LOCAL_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			(
						    F'{MODEL_NAME}_rank{accelerator.process_index}.bin'
						    if model_index == 0
						    else F'{MODEL_NAME}_{model_index}_rank{accelerator.process_index}.bin'
						)
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
						logger.info(F'Loading model from {input_model_file}'     )
						SCREAMING_SNAKE_CASE_    			=			torch.load(__a     )
						logger.info(F'Model loaded from {input_model_file}'     )
				elif fsdp_plugin.state_dict_type == StateDictType.SHARDED_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			(
						    os.path.join(__a,				F'{MODEL_NAME}_{model_index}'     )
						    if F'{MODEL_NAME}' not in input_dir
						    else input_dir
						)
						logger.info(F'Loading model from {ckpt_dir}'     )
						SCREAMING_SNAKE_CASE_    			=			{'''model''': model.state_dict()}
						dist_cp.load_state_dict(
						    state_dict=__a,				storage_reader=dist_cp.FileSystemReader(__a     ),				planner=DefaultLoadPlanner(),				)
						SCREAMING_SNAKE_CASE_    			=			state_dict['''model''']
						logger.info(F'Model loaded from {ckpt_dir}'     )
				model.load_state_dict(__a     )



def 							_lowerCamelCase			(			__a,				__a,				__a,				__a,				__a,				__a=0     ):
		os.makedirs(__a,				exist_ok=__a     )
		with FSDP.state_dict_type(
		    __a,				fsdp_plugin.state_dict_type,				fsdp_plugin.state_dict_config,				fsdp_plugin.optim_state_dict_config     ):
				SCREAMING_SNAKE_CASE_    			=			FSDP.optim_state_dict(__a,				__a     )
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						if accelerator.process_index == 0:
								SCREAMING_SNAKE_CASE_    			=			(
								    F'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else F'{OPTIMIZER_NAME}_{optimizer_index}.bin'
								)
								SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
								logger.info(F'Saving Optimizer state to {output_optimizer_file}'     )
								torch.save(__a,				__a     )
								logger.info(F'Optimizer state saved in {output_optimizer_file}'     )
				else:
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				F'{OPTIMIZER_NAME}_{optimizer_index}'     )
						os.makedirs(__a,				exist_ok=__a     )
						logger.info(F'Saving Optimizer state to {ckpt_dir}'     )
						dist_cp.save_state_dict(
						    state_dict={'''optimizer''': optim_state},				storage_writer=dist_cp.FileSystemWriter(__a     ),				planner=DefaultSavePlanner(),				)
						logger.info(F'Optimizer state saved in {ckpt_dir}'     )



def 							_lowerCamelCase			(			__a,				__a,				__a,				__a,				__a,				__a=0     ):
		accelerator.wait_for_everyone()
		with FSDP.state_dict_type(
		    __a,				fsdp_plugin.state_dict_type,				fsdp_plugin.state_dict_config,				fsdp_plugin.optim_state_dict_config     ):
				if fsdp_plugin.state_dict_type == StateDictType.FULL_STATE_DICT:
						SCREAMING_SNAKE_CASE_    			=			None
						# below check should work but currently it isn't working (mostly opytorch issue),
						# in the meantime disabling it at the cost of excess memory usage
						# if accelerator.process_index == 0 or not fsdp_plugin.optim_state_dict_config.rank0_only:
						SCREAMING_SNAKE_CASE_    			=			(
						    F'{OPTIMIZER_NAME}.bin' if optimizer_index == 0 else F'{OPTIMIZER_NAME}_{optimizer_index}.bin'
						)
						SCREAMING_SNAKE_CASE_    			=			os.path.join(__a,				__a     )
						logger.info(F'Loading Optimizer state from {input_optimizer_file}'     )
						SCREAMING_SNAKE_CASE_    			=			torch.load(__a     )
						logger.info(F'Optimizer state loaded from {input_optimizer_file}'     )
				else:
						SCREAMING_SNAKE_CASE_    			=			(
						    os.path.join(__a,				F'{OPTIMIZER_NAME}_{optimizer_index}'     )
						    if F'{OPTIMIZER_NAME}' not in input_dir
						    else input_dir
						)
						logger.info(F'Loading Optimizer from {ckpt_dir}'     )
						SCREAMING_SNAKE_CASE_    			=			load_sharded_optimizer_state_dict(
						    model_state_dict=model.state_dict(),				optimizer_key='''optimizer''',				storage_reader=dist_cp.FileSystemReader(__a     ),				)
						SCREAMING_SNAKE_CASE_    			=			optim_state['''optimizer''']
						logger.info(F'Optimizer loaded from {ckpt_dir}'     )
				SCREAMING_SNAKE_CASE_    			=			FSDP.optim_state_dict_to_load(__a,				__a,				__a     )
				optimizer.load_state_dict(__a     )