


"""simple docstring"""



import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


__snake_case   			=    logging.get_logger(__name__)
__snake_case   			=    {"""vocab_file""": """spiece.model"""}

__snake_case   			=    {
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    }
}

__snake_case   			=    {
    """albert-base-v1""": 512,
    """albert-large-v1""": 512,
    """albert-xlarge-v1""": 512,
    """albert-xxlarge-v1""": 512,
    """albert-base-v2""": 512,
    """albert-large-v2""": 512,
    """albert-xlarge-v2""": 512,
    """albert-xxlarge-v2""": 512,
}

__snake_case   			=    """▁"""







class _lowerCAmelCase				(      _snake_case	):
   __UpperCAmelCase :       Union[str, Any]							  =  VOCAB_FILES_NAMES
   __UpperCAmelCase :       List[str]							  =  PRETRAINED_VOCAB_FILES_MAP
   __UpperCAmelCase :       Tuple							  =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES







   def __init__(	self						,	UpperCamelCase__						,	UpperCamelCase__=True						,	UpperCamelCase__=True						,	UpperCamelCase__=False						,	UpperCamelCase__="[CLS]"						,	UpperCamelCase__="[SEP]"						,	UpperCamelCase__="<unk>"						,	UpperCamelCase__="[SEP]"						,	UpperCamelCase__="<pad>"						,	UpperCamelCase__="[CLS]"						,	UpperCamelCase__="[MASK]"						,	UpperCamelCase__ = None						,	**UpperCamelCase__						,	)	->		None:

       '''simple docstring'''




       snake_case    :      Dict      					=    (
           AddedToken(_UpperCamelCase						,	lstrip=_UpperCamelCase						,	rstrip=_UpperCamelCase						,	normalized=_UpperCamelCase						)
           if isinstance(_UpperCamelCase						,	_UpperCamelCase						)
           else mask_token
       )

       snake_case    :      Tuple      					=    {} if sp_model_kwargs is None else sp_model_kwargs

       super().__init__(
           do_lower_case=_UpperCamelCase						,	remove_space=_UpperCamelCase						,	keep_accents=_UpperCamelCase						,	bos_token=_UpperCamelCase						,	eos_token=_UpperCamelCase						,	unk_token=_UpperCamelCase						,	sep_token=_UpperCamelCase						,	pad_token=_UpperCamelCase						,	cls_token=_UpperCamelCase						,	mask_token=_UpperCamelCase						,	sp_model_kwargs=self.sp_model_kwargs						,	**_UpperCamelCase						,	)

       snake_case    :      List[str]      					=    do_lower_case
       snake_case    :      Optional[Any]      					=    remove_space
       snake_case    :      Union[str, Any]      					=    keep_accents
       snake_case    :      Any      					=    vocab_file

       snake_case    :      str      					=    spm.SentencePieceProcessor(**self.sp_model_kwargs						)
       self.sp_model.Load(_UpperCamelCase						)







   @property
   def  lowerCamelCase		(	self						)	->		Union[str, Any]:

       '''simple docstring'''




       return len(self.sp_model						)







   def  lowerCamelCase		(	self						)	->		Optional[Any]:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    {self.convert_ids_to_tokens(_UpperCamelCase						): i for i in range(self.vocab_size						)}
       vocab.update(self.added_tokens_encoder						)
       return vocab







   def __getstate__(	self						)	->		Union[str, Any]:

       '''simple docstring'''




       snake_case    :      List[str]      					=    self.__dict__.copy()
       snake_case    :      Any      					=    None
       return state







   def __setstate__(	self						,	UpperCamelCase__						)	->		Union[str, Any]:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    d

       # for backward compatibility
       if not hasattr(self						,	"sp_model_kwargs"						):
           snake_case    :      Dict      					=    {}

       snake_case    :      Optional[Any]      					=    spm.SentencePieceProcessor(**self.sp_model_kwargs						)
       self.sp_model.Load(self.vocab_file						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		List[str]:

       '''simple docstring'''




       if self.remove_space:
           snake_case    :      Tuple      					=    ' '.join(inputs.strip().split()						)
       else:
           snake_case    :      List[Any]      					=    inputs
       snake_case    :      int      					=    outputs.replace("``"						,	"\""						).replace("\'\'"						,	"\""						)

       if not self.keep_accents:
           snake_case    :      int      					=    unicodedata.normalize("NFKD"						,	_UpperCamelCase						)
           snake_case    :      str      					=    ''.join([c for c in outputs if not unicodedata.combining(_UpperCamelCase						)]						)
       if self.do_lower_case:
           snake_case    :      Optional[int]      					=    outputs.lower()

       return outputs







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		List[str]:

       '''simple docstring'''




       snake_case    :      Any      					=    self.preprocess_text(_UpperCamelCase						)
       snake_case    :      int      					=    self.sp_model.encode(_UpperCamelCase						,	out_type=_UpperCamelCase						)
       snake_case    :      Any      					=    []
       for piece in pieces:
           if len(_UpperCamelCase						) > 1 and piece[-1] == str(","						) and piece[-2].isdigit():
               snake_case    :      List[str]      					=    self.sp_model.EncodeAsPieces(piece[:-1].replace(_UpperCamelCase						,	""						)						)
               if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
                   if len(cur_pieces[0]						) == 1:
                       snake_case    :      Union[str, Any]      					=    cur_pieces[1:]
                   else:
                       snake_case    :      str      					=    cur_pieces[0][1:]
               cur_pieces.append(piece[-1]						)
               new_pieces.extend(_UpperCamelCase						)
           else:
               new_pieces.append(_UpperCamelCase						)

       return new_pieces







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Any:

       '''simple docstring'''




       return self.sp_model.PieceToId(_UpperCamelCase						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Tuple:

       '''simple docstring'''




       return self.sp_model.IdToPiece(_UpperCamelCase						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Optional[Any]:

       '''simple docstring'''




       snake_case    :      Any      					=    []
       snake_case    :      List[Any]      					=    ''
       snake_case    :      List[str]      					=    False
       for token in tokens:
           # make sure that special tokens are not decoded using sentencepiece model
           if token in self.all_special_tokens:
               if not prev_is_special:
                   out_string += " "
               out_string += self.sp_model.decode(_UpperCamelCase						) + token
               snake_case    :      Tuple      					=    True
               snake_case    :      Optional[int]      					=    []
           else:
               current_sub_tokens.append(_UpperCamelCase						)
               snake_case    :      Optional[Any]      					=    False
       out_string += self.sp_model.decode(_UpperCamelCase						)
       return out_string.strip()







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__ = None						)	->		List[int]:

       '''simple docstring'''




       snake_case    :      Tuple      					=    [self.sep_token_id]
       snake_case    :      Union[str, Any]      					=    [self.cls_token_id]
       if token_ids_a is None:
           return cls + token_ids_a + sep
       return cls + token_ids_a + sep + token_ids_a + sep







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__ = None						,	UpperCamelCase__ = False						)	->		List[int]:

       '''simple docstring'''




       if already_has_special_tokens:
           return super().get_special_tokens_mask(
               token_ids_a=_UpperCamelCase						,	token_ids_a=_UpperCamelCase						,	already_has_special_tokens=_UpperCamelCase						)

       if token_ids_a is not None:
           return [1] + ([0] * len(_UpperCamelCase						)) + [1] + ([0] * len(_UpperCamelCase						)) + [1]
       return [1] + ([0] * len(_UpperCamelCase						)) + [1]







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__ = None						)	->		List[int]:

       '''simple docstring'''




       snake_case    :      int      					=    [self.sep_token_id]
       snake_case    :      List[Any]      					=    [self.cls_token_id]

       if token_ids_a is None:
           return len(cls + token_ids_a + sep						) * [0]
       return len(cls + token_ids_a + sep						) * [0] + len(token_ids_a + sep						) * [1]







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__ = None						)	->		Tuple[str]:

       '''simple docstring'''




       if not os.path.isdir(_UpperCamelCase						):
           logger.error(F'Vocabulary path ({save_directory}) should be a directory'						)
           return
       snake_case    :      int      					=    os.path.join(
           _UpperCamelCase						,	(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"]						)

       if os.path.abspath(self.vocab_file						) != os.path.abspath(_UpperCamelCase						) and os.path.isfile(self.vocab_file						):
           copyfile(self.vocab_file						,	_UpperCamelCase						)
       elif not os.path.isfile(self.vocab_file						):
           with open(_UpperCamelCase						,	"wb"						) as fi:
               snake_case    :      Tuple      					=    self.sp_model.serialized_model_proto()
               fi.write(_UpperCamelCase						)

       return (out_vocab_file,)













import inspect
import logging
import os
import random
import shutil
import tempfile
import unittest

import pytest
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset

from accelerate import Accelerator
from accelerate.test_utils import execute_subprocess_async, require_cuda
from accelerate.utils import ProjectConfiguration, set_seed


__UpperCAmelCase								=						logging.getLogger(__name__)




def      lowercase__      (     __snake_case    :							List[Any]=2     ,       __snake_case    :							Union[str, Any]=3     ,       __snake_case    :							Any=16     ,       __snake_case    :							int = 10     ,       __snake_case    :							int = 2  ):


					'''simple docstring'''


					def get_dataset(__snake_case    :							Optional[Any]  ):
										UpperCAmelCase_    :      Optional[Any]            =						torch.randn(batch_size * n_batches     ,       1  )
										return TensorDataset(__snake_case     ,       a * x + b + 0.1 * torch.randn(batch_size * n_batches     ,       1  )  )

					UpperCAmelCase_    :      Any            =						get_dataset(__snake_case  )
					UpperCAmelCase_    :      str            =						get_dataset(__snake_case  )
					UpperCAmelCase_    :      int            =						DataLoader(__snake_case     ,       shuffle=__snake_case     ,       batch_size=__snake_case     ,       num_workers=4  )
					UpperCAmelCase_    :      int            =						DataLoader(__snake_case     ,       shuffle=__snake_case     ,       batch_size=__snake_case     ,       num_workers=4  )
					return (train_dataloader, valid_dataloader)




def      lowercase__      (     __snake_case    :							Optional[int]     ,       __snake_case    :							str     ,       __snake_case    :							Optional[int]     ,       __snake_case    :							List[str]     ,       __snake_case    :							Any     ,       __snake_case    :							Tuple=None  ):


					'''simple docstring'''


					UpperCAmelCase_    :      Optional[int]            =						[]
					for epoch in range(__snake_case  ):
										# Train quickly
										model.train()
										for batch in dataloader:
															UpperCAmelCase_       ,  UpperCAmelCase_    :      List[Any]            =						batch
															UpperCAmelCase_    :      List[Any]            =						model(__snake_case  )
															UpperCAmelCase_    :      int            =						torch.nn.functional.mse_loss(__snake_case     ,       __snake_case  )
															accelerator.backward(__snake_case  )
															optimizer.step()
															optimizer.zero_grad()
										rands.append(random.random()  )  # Introduce some randomness
										if scheduler is not None:
															scheduler.step()
					return rands



class   lowerCamelCase      (nn.Module			):







		'''simple docstring'''



		def __init__(							self   )	->							Optional[Any]:
							super().__init__()
							UpperCAmelCase_    :      List[Any]            =						nn.Parameter(torch.randn(1   )   )
							UpperCAmelCase_    :      Optional[int]            =						nn.Parameter(torch.randn(1   )   )



		def 					__UpperCAmelCase			(							self				,		_UpperCamelCase   )	->							Optional[Any]:
							return x * self.a + self.b





class   lowerCamelCase      (unittest.TestCase			):







		'''simple docstring'''



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							with tempfile.TemporaryDirectory() as tmpdir:
												set_seed(4_2   )
												UpperCAmelCase_    :      Tuple            =						DummyModel()
												UpperCAmelCase_    :      List[str]            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      Union[str, Any]            =						dummy_dataloaders()
												UpperCAmelCase_    :      Optional[int]            =						ProjectConfiguration(total_limit=1				,		project_dir=_UpperCamelCase				,		automatic_checkpoint_naming=_UpperCamelCase   )
												# Train baseline
												UpperCAmelCase_    :      Dict            =						Accelerator(project_config=_UpperCamelCase   )
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      str            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save initial
												accelerator.save_state()

												# Save second state
												accelerator.save_state()
												self.assertEqual(len(os.listdir(accelerator.project_dir   )   )				,		1   )



		def 					__UpperCAmelCase			(							self   )	->							int:
							with tempfile.TemporaryDirectory() as tmpdir:
												set_seed(4_2   )
												UpperCAmelCase_    :      Optional[Any]            =						DummyModel()
												UpperCAmelCase_    :      str            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						dummy_dataloaders()
												# Train baseline
												UpperCAmelCase_    :      Tuple            =						Accelerator()
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Optional[Any]            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save initial
												UpperCAmelCase_    :      Any            =						os.path.join(_UpperCamelCase				,		'initial'   )
												accelerator.save_state(_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      Optional[int]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Dict            =						optimizer.state_dict()
												UpperCAmelCase_    :      Union[str, Any]            =						train(3				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      Union[str, Any]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Any            =						optimizer.state_dict()

												# Train partially
												set_seed(4_2   )
												UpperCAmelCase_    :      int            =						DummyModel()
												UpperCAmelCase_    :      int            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      str            =						dummy_dataloaders()
												UpperCAmelCase_    :      Optional[Any]            =						Accelerator()
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												accelerator.load_state(_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      List[str]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Optional[Any]            =						optimizer.state_dict()
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )

												UpperCAmelCase_    :      Dict            =						train(2				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save everything
												UpperCAmelCase_    :      Union[str, Any]            =						os.path.join(_UpperCamelCase				,		'checkpoint'   )
												accelerator.save_state(_UpperCamelCase   )

												# Load everything back in and make sure all states work
												accelerator.load_state(_UpperCamelCase   )
												test_rands += train(1				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      Optional[Any]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Union[str, Any]            =						optimizer.state_dict()
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							int:
							with tempfile.TemporaryDirectory() as tmpdir:
												set_seed(4_2   )
												UpperCAmelCase_    :      Tuple            =						DummyModel()
												UpperCAmelCase_    :      Optional[int]            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      Optional[int]            =						dummy_dataloaders()
												UpperCAmelCase_    :      Any            =						ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase   )

												# Train baseline
												UpperCAmelCase_    :      str            =						Accelerator(project_dir=_UpperCamelCase				,		project_config=_UpperCamelCase   )
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Any            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save initial
												accelerator.save_state()
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      Optional[int]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Optional[int]            =						optimizer.state_dict()
												UpperCAmelCase_    :      Optional[Any]            =						train(3				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      Tuple            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Optional[int]            =						optimizer.state_dict()

												# Train partially
												set_seed(4_2   )
												UpperCAmelCase_    :      Any            =						DummyModel()
												UpperCAmelCase_    :      Any            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      Union[str, Any]            =						dummy_dataloaders()
												UpperCAmelCase_    :      Tuple            =						ProjectConfiguration(iteration=1				,		automatic_checkpoint_naming=_UpperCamelCase   )
												UpperCAmelCase_    :      List[Any]            =						Accelerator(project_dir=_UpperCamelCase				,		project_config=_UpperCamelCase   )
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Any            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												accelerator.load_state(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_0'   )   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      str            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      List[Any]            =						optimizer.state_dict()
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )

												UpperCAmelCase_    :      Union[str, Any]            =						train(2				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save everything
												accelerator.save_state()

												# Load everything back in and make sure all states work
												accelerator.load_state(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_1'   )   )
												test_rands += train(1				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												((UpperCAmelCase_)       ,  (UpperCAmelCase_))    :      List[Any]            =						model.a.item(), model.b.item()
												UpperCAmelCase_    :      Dict            =						optimizer.state_dict()
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )
												self.assertEqual(_UpperCamelCase				,		_UpperCamelCase   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							UpperCAmelCase_    :      Optional[Any]            =						torch.tensor([1, 2, 3]   )
							UpperCAmelCase_    :      Any            =						torch.tensor([2, 3, 4]   )
							UpperCAmelCase_    :      Union[str, Any]            =						DummyModel()
							UpperCAmelCase_    :      List[str]            =						torch.optim.Adam(net.parameters()   )
							UpperCAmelCase_    :      Any            =						Accelerator()
							with self.assertRaises(_UpperCamelCase   ) as ve:
												accelerator.register_for_checkpointing(_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
							UpperCAmelCase_    :      Optional[int]            =						str(ve.exception   )
							self.assertTrue('Item at index 0' in message   )
							self.assertTrue('Item at index 1' in message   )
							self.assertFalse('Item at index 2' in message   )
							self.assertFalse('Item at index 3' in message   )



		def 					__UpperCAmelCase			(							self   )	->							int:
							with tempfile.TemporaryDirectory() as tmpdir:
												set_seed(4_2   )
												UpperCAmelCase_    :      int            =						DummyModel()
												UpperCAmelCase_    :      Any            =						torch.optim.Adam(params=model.parameters()				,		lr=1E-3   )
												UpperCAmelCase_    :      Dict            =						torch.optim.lr_scheduler.StepLR(_UpperCamelCase				,		step_size=1				,		gamma=0.99   )
												UpperCAmelCase_       ,  UpperCAmelCase_    :      Tuple            =						dummy_dataloaders()
												UpperCAmelCase_    :      Tuple            =						ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase   )
												# Train baseline
												UpperCAmelCase_    :      Tuple            =						Accelerator(project_dir=_UpperCamelCase				,		project_config=_UpperCamelCase   )
												UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_       ,  UpperCAmelCase_    :      Any            =						accelerator.prepare(
												    _UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												# Save initial
												accelerator.save_state()
												UpperCAmelCase_    :      Dict            =						scheduler.state_dict()
												train(3				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase				,		_UpperCamelCase   )
												self.assertNotEqual(_UpperCamelCase				,		scheduler.state_dict()   )

												# Load everything back in and make sure all states work
												accelerator.load_state(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_0'   )   )
												self.assertEqual(_UpperCamelCase				,		scheduler.state_dict()   )



		def 					__UpperCAmelCase			(							self   )	->							Dict:
							with tempfile.TemporaryDirectory() as tmpdir:
												set_seed(4_2   )
												UpperCAmelCase_    :      Optional[int]            =						DummyModel()
												UpperCAmelCase_    :      Dict            =						ProjectConfiguration(automatic_checkpoint_naming=_UpperCamelCase				,		total_limit=2   )
												# Train baseline
												UpperCAmelCase_    :      Optional[int]            =						Accelerator(project_dir=_UpperCamelCase				,		project_config=_UpperCamelCase   )
												UpperCAmelCase_    :      str            =						accelerator.prepare(_UpperCamelCase   )
												# Save 3 states:
												for _ in range(1_1   ):
																	accelerator.save_state()
												self.assertTrue(not os.path.exists(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_0'   )   )   )
												self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_9'   )   )   )
												self.assertTrue(os.path.exists(os.path.join(_UpperCamelCase				,		'checkpoints'				,		'checkpoint_10'   )   )   )



		@require_cuda
		def 					__UpperCAmelCase			(							self   )	->							str:
							UpperCAmelCase_    :      List[str]            =						['torchrun', f"--nproc_per_node={torch.cuda.device_count()}", inspect.getfile(self.__class__   )]
							execute_subprocess_async(_UpperCamelCase				,		env=os.environ.copy()   )


if __name__ == "__main__":
		__UpperCAmelCase								=						'/tmp/accelerate/state_checkpointing'
		__UpperCAmelCase								=						DummyModel()
		__UpperCAmelCase								=						torch.optim.Adam(params=model.parameters(), lr=1E-3)
		__UpperCAmelCase								=						torch.optim.lr_scheduler.StepLR(optimizer, step_size=1, gamma=0.9_9)
		__UpperCAmelCase							,   __UpperCAmelCase								=						dummy_dataloaders()
		__UpperCAmelCase								=						ProjectConfiguration(automatic_checkpoint_naming=True)
		# Train baseline
		__UpperCAmelCase								=						Accelerator(project_dir=savedir, project_config=project_config, mixed_precision='no')
		if accelerator.process_index == 0:
				if os.path.exists(savedir):
						shutil.rmtree(savedir)
				os.makedirs(savedir)
		__UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase								=						accelerator.prepare(
		    model, optimizer, train_dataloader, valid_dataloader, scheduler
		)
		__UpperCAmelCase							,   __UpperCAmelCase								=						accelerator.prepare(model, optimizer)
		train(3, model, train_dataloader, optimizer, accelerator, scheduler)
		# Check that the intial optimizer is loaded on the GPU
		for group in optimizer.param_groups:
				__UpperCAmelCase								=						group['params'][0].device
				break
		assert param_device.type == accelerator.device.type
		__UpperCAmelCase								=						model.cpu()
		accelerator.wait_for_everyone()
		accelerator.save_state()
		accelerator.wait_for_everyone()

		# Check CPU state
		accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='cpu')
		for group in optimizer.param_groups:
				__UpperCAmelCase								=						group['params'][0].device
				break
		assert (
		    param_device.type == torch.device('cpu').type
		), F"Loaded optimizer states did not match, expected to be loaded on the CPU but got {param_device}"

		# Check device state
		model.to(accelerator.device)
		accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='on_device')
		for group in optimizer.param_groups:
				__UpperCAmelCase								=						group['params'][0].device
				break
		assert (
		    param_device.type == accelerator.device.type
		), F"Loaded optimizer states did not match, expected to be loaded on {accelerator.device} but got {param_device}"

		# Check error
		with pytest.raises(TypeError, match='Unsupported optimizer map location passed'):
				accelerator.load_state(os.path.join(savedir, 'checkpoints', 'checkpoint_0'), map_location='invalid')
		accelerator.wait_for_everyone()
		if accelerator.process_index == 0:
				shutil.rmtree(savedir)
		accelerator.wait_for_everyone()






