





import json
import os
import tempfile
from unittest.mock import patch

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

from accelerate import DistributedType, infer_auto_device_map, init_empty_weights
from accelerate.accelerator import Accelerator
from accelerate.state import GradientState, PartialState
from accelerate.test_utils import require_bnb, require_multi_gpu, slow
from accelerate.test_utils.testing import AccelerateTestCase, require_cuda
from accelerate.utils import patch_environment


def _A       (   ):
   lowercase__			       =  torch.nn.Linear(2  , 4	)
   lowercase__			       =  torch.optim.AdamW(model.parameters()  , lr=1.0	)
   lowercase__			       =  torch.optim.lr_scheduler.OneCycleLR(__magic_name__  , max_lr=0.01  , steps_per_epoch=2  , epochs=1	)
   lowercase__			       =  DataLoader(TensorDataset(torch.tensor([1, 2, 3]	)	)	)
   lowercase__			       =  DataLoader(TensorDataset(torch.tensor([4, 5, 6]	)	)	)

   return model, optimizer, scheduler, train_dl, valid_dl


def _A       (   __magic_name__	):
   return (model.weight.abs().sum() + model.bias.abs().sum()).item()


def _A       (   __magic_name__	):
   lowercase__			       =  torch.nn.Linear(*tuple(model.weight.T.shape	)	).state_dict()
   model.load_state_dict(__magic_name__	)







class  lowerCAmelCase							(       lowercase_ ):







  @require_cuda
  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     assert PartialState._shared_state["_cpu"] is False
     assert PartialState._shared_state["device"].type == "cuda"
     with self.assertRaises(_lowercase ):
        lowercase__			       =  Accelerator(cpu=_lowercase )







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__			       =  GradientState()
     assert state.num_steps == 1
     lowercase__			       =  4
     assert state.num_steps == 4

     assert state.sync_gradients is True
     lowercase__			       =  False
     assert state.sync_gradients is False
     GradientState._reset_state()







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()

     (
         (
         lowercase__
     )       ,							(
         lowercase__
     )       ,							(
         lowercase__
     )       ,							(
         lowercase__
     )       ,							(
         lowercase__
     )       ,							
     )			       =  accelerator.prepare(_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )

     self.assertTrue(prepared_model in accelerator._models )
     self.assertTrue(prepared_optimizer in accelerator._optimizers )
     self.assertTrue(prepared_scheduler in accelerator._schedulers )
     self.assertTrue(prepared_train_dl in accelerator._dataloaders )
     self.assertTrue(prepared_valid_dl in accelerator._dataloaders )







  def   UpperCAmelCase					(      self  :List[Any] ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()
     accelerator.prepare(_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )
     accelerator.free_memory()

     self.assertTrue(len(accelerator._models ) == 0 )
     self.assertTrue(len(accelerator._optimizers ) == 0 )
     self.assertTrue(len(accelerator._schedulers ) == 0 )
     self.assertTrue(len(accelerator._dataloaders ) == 0 )







  def   UpperCAmelCase					(      self  :int ):






     '''simple docstring'''





     PartialState._reset_state()

     # Mock torch.cuda.set_device to avoid an exception as the device doesn't exist
     def noop(*_lowercase  :int   ,							**_lowercase  :Optional[int] ):
        pass

     with patch("torch.cuda.set_device"   ,							_lowercase ), patch_environment(ACCELERATE_TORCH_DEVICE="cuda:64" ):
        lowercase__			       =  Accelerator()
        self.assertEqual(str(accelerator.state.device )   ,							"cuda:64" )







  def   UpperCAmelCase					(      self  :Union[str, Any] ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()
     accelerator.prepare(_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )

     lowercase__			       =  get_signature(_lowercase )

     with tempfile.TemporaryDirectory() as tmpdirname:
        accelerator.save_state(_lowercase )

        # make sure random weights don't match
        load_random_weights(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) > 1e-3 )

        # make sure loaded weights match
        accelerator.load_state(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) < 1e-3 )







  def   UpperCAmelCase					(      self  :Optional[Any] ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()
     accelerator.prepare(_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )

     lowercase__			       =  get_signature(_lowercase )

     # saving hook
     def save_config(_lowercase  :List[Any]   ,							_lowercase  :Optional[int]   ,							_lowercase  :Optional[int] ):
        lowercase__			       =  {"class_name": models[0].__class__.__name__}

        with open(os.path.join(_lowercase   ,							"data.json" )   ,							"w" ) as f:
           json.dump(_lowercase   ,							_lowercase )

        # loading hook
     def load_config(_lowercase  :List[str]   ,							_lowercase  :str ):
        with open(os.path.join(_lowercase   ,							"data.json" )   ,							"r" ) as f:
           lowercase__			       =  json.load(_lowercase )

        lowercase__			       =  config["class_name"]

     lowercase__			       =  accelerator.register_save_state_pre_hook(_lowercase )
     lowercase__			       =  accelerator.register_load_state_pre_hook(_lowercase )

     with tempfile.TemporaryDirectory() as tmpdirname:
        accelerator.save_state(_lowercase )

        # make sure random weights don't match with hooks
        load_random_weights(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) > 1e-3 )

        # random class name to verify correct one is loaded
        lowercase__			       =  "random"

        # make sure loaded weights match with hooks
        accelerator.load_state(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) < 1e-3 )

        # mode.class_name is loaded from config
        self.assertTrue(model.class_name == model.__class__.__name__ )

     # remove hooks
     save_hook.remove()
     load_hook.remove()

     with tempfile.TemporaryDirectory() as tmpdirname:
        accelerator.save_state(_lowercase )

        # make sure random weights don't match with hooks removed
        load_random_weights(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) > 1e-3 )

        # random class name to verify correct one is loaded
        lowercase__			       =  "random"

        # make sure loaded weights match with hooks removed
        accelerator.load_state(_lowercase )
        self.assertTrue(abs(model_signature - get_signature(_lowercase ) ) < 1e-3 )

        # mode.class_name is NOT loaded from config
        self.assertTrue(model.class_name != model.__class__.__name__ )







  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()
     lowercase__			       =  None

     # This should work
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  accelerator.prepare(
         _lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )
     self.assertTrue(dummy_obj is None )







  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     lowercase__			       =  Accelerator()
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  create_components()
     lowercase__			       =  [1, 2, 3]

     # This should work
     lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__       ,							lowercase__			       =  accelerator.prepare(
         _lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase   ,							_lowercase )
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Dummy object should have `_is_accelerate_prepared` set to `True`"   ,							)
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Model is missing `_is_accelerator_prepared` or is set to `False`"   ,							)
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Optimizer is missing `_is_accelerator_prepared` or is set to `False`"   ,							)
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Scheduler is missing `_is_accelerator_prepared` or is set to `False`"   ,							)
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Train Dataloader is missing `_is_accelerator_prepared` or is set to `False`"   ,							)
     self.assertEqual(
         getattr(_lowercase   ,							"_is_accelerate_prepared"   ,							_lowercase )   ,							_lowercase   ,							"Valid Dataloader is missing `_is_accelerator_prepared` or is set to `False`"   ,							)







  @slow
  @require_bnb
  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     from transformers import AutoModelForCausalLM

     lowercase__			       =  AutoModelForCausalLM.from_pretrained(
         "EleutherAI/gpt-neo-125m"   ,							load_in_abit=_lowercase   ,							device_map={"": 0}   ,							)
     lowercase__			       =  Accelerator()

     # This should work
     lowercase__			       =  accelerator.prepare(_lowercase )







  @slow
  @require_bnb
  def   UpperCAmelCase					(      self  :Dict ):






     '''simple docstring'''





     from transformers import AutoModelForCausalLM

     lowercase__			       =  Accelerator()

     with init_empty_weights():
        lowercase__			       =  AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"   ,							)
        model.tie_weights()
        lowercase__			       =  infer_auto_device_map(_lowercase )
        lowercase__			       =  "cpu"

     lowercase__			       =  AutoModelForCausalLM.from_pretrained(
         "EleutherAI/gpt-neo-125m"   ,							device_map=_lowercase   ,							load_in_abit=_lowercase   ,							llm_inta_enable_fpaa_cpu_offload=_lowercase )

     # This should not work and get value error
     with self.assertRaises(_lowercase ):
        lowercase__			       =  accelerator.prepare(_lowercase )







  @slow
  @require_bnb
  @require_multi_gpu
  def   UpperCAmelCase					(      self  :Tuple ):






     '''simple docstring'''





     from transformers import AutoModelForCausalLM

     lowercase__			       =  {"distributed_type": DistributedType.MULTI_GPU}

     with init_empty_weights():
        lowercase__			       =  AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"   ,							)
        model.tie_weights()
        lowercase__			       =  infer_auto_device_map(_lowercase )
        lowercase__			       =  1

     lowercase__			       =  AutoModelForCausalLM.from_pretrained(
         "EleutherAI/gpt-neo-125m"   ,							load_in_abit=_lowercase   ,							device_map=_lowercase   ,							)
     lowercase__			       =  Accelerator()

     # This should not work and get value error
     with self.assertRaises(_lowercase ):
        lowercase__			       =  accelerator.prepare(_lowercase )

     PartialState._reset_state()







  @slow
  @require_bnb
  @require_multi_gpu
  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     from transformers import AutoModelForCausalLM

     with init_empty_weights():
        lowercase__			       =  AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"   ,							)
        lowercase__			       =  infer_auto_device_map(_lowercase )
        lowercase__			       =  1

     lowercase__			       =  AutoModelForCausalLM.from_pretrained(
         "EleutherAI/gpt-neo-125m"   ,							load_in_abit=_lowercase   ,							device_map=_lowercase   ,							)
     lowercase__			       =  Accelerator()

     # This should work
     lowercase__			       =  accelerator.prepare(_lowercase )







  @require_cuda
  def   UpperCAmelCase					(      self  :Optional[int] ):






     '''simple docstring'''





     lowercase__			       =  torch.nn.Linear(10   ,							10 )
     lowercase__			       =  torch.optim.SGD(model.parameters()   ,							lr=0.01 )
     lowercase__			       =  Accelerator(cpu=_lowercase )
     lowercase__			       =  accelerator.prepare(_lowercase )













from __future__ import annotations


def _A       (   __magic_name__  , __magic_name__	):
   lowercase__			       =  0
   lowercase__			       =  len(__magic_name__	) - 1

   while i < j:
      if nums[i] + nums[j] == target:
         return [i, j]
      elif nums[i] + nums[j] < target:
         lowercase__			       =  i + 1
      else:
         lowercase__			       =  j - 1

   return []


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(F"""{two_pointer([2, 7, 11, 15], 9) = }""")






