


"""simple docstring"""







from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    AutoTokenizer,
	    TFAutoModelForCausalLM,
	    TFAutoModelForSeqaSeqLM,
	    TFAutoModelForSpeechSeqaSeq,
	    TFAutoModelForVisionaSeq,
	    TFBartForConditionalGeneration,
	    TFLogitsProcessorList,
	    TFMinLengthLogitsProcessor,
	    tf_top_k_top_p_filtering,
	)

if is_tensorflow_text_available():
	import tensorflow_text as text






@require_tf
class 						_A  (  unittest.TestCase  ):







				"""simple docstring"""




				def      __snake_case							( self    :   Optional[int]):
						a						:		Union[str, Any]											=      tf.convert_to_tensor(
						    [
						        [
						            8.2_220_991,  # 3rd highest value; idx. 0
						            -0.5_620_044,
						            5.23_229_752,
						            4.0_386_393,
						            -6.8_798_378,
						            -0.54_785_802,
						            -3.2_012_153,
						            2.92_777_176,
						            1.88_171_953,
						            7.35_341_276,  # 5th highest value; idx. 9
						            8.43_207_833,  # 2nd highest value; idx. 10
						            -9.85_711_836,
						            -5.96_209_236,
						            -1.13_039_161,
						            -7.1_115_294,
						            -0.8_369_633,
						            -5.3_186_408,
						            7.06_427_407,
						            0.81_369_344,
						            -0.82_023_817,
						            -5.9_179_796,
						            0.58_813_443,
						            -6.99_778_438,
						            4.71_551_189,
						            -0.18_771_637,
						            7.44_020_759,  # 4th highest value; idx. 25
						            9.38_450_987,  # 1st highest value; idx. 26
						            2.12_662_941,
						            -9.32_562_038,
						            2.35_652_522,
						        ],  # cummulative prob of 5 highest values <= 0.6
						        [
						            0.58_425_518,
						            4.53_139_238,
						            -5.57_510_464,
						            -6.28_030_699,
						            -7.19_529_503,
						            -4.02_122_551,
						            1.39_337_037,
						            -6.06_707_057,
						            1.59_480_517,
						            -9.643_119,
						            0.03_907_799,
						            0.67_231_762,
						            -8.88_206_726,
						            6.27_115_922,  # 4th highest value; idx. 13
						            2.28_520_723,
						            4.82_767_506,
						            4.30_421_368,
						            8.8_275_313,  # 2nd highest value; idx. 17
						            5.44_029_958,  # 5th highest value; idx. 18
						            -4.4_735_794,
						            7.38_579_536,  # 3rd highest value; idx. 20
						            -2.91_051_663,
						            2.61_946_077,
						            -2.5_674_762,
						            -9.48_959_302,
						            -4.02_922_645,
						            -1.35_416_918,
						            9.67_702_323,  # 1st highest value; idx. 27
						            -5.89_478_553,
						            1.85_370_467,
						        ],  # cummulative prob of 5 highest values <= 0.6
						    ]    ,			dtype=tf.floataa    ,			)

						a						:		List[Any]											=      tf.convert_to_tensor(
						    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]    ,			dtype=tf.intaa    ,			)  # expected non filtered idx as noted above

						a						:		List[Any]											=      tf.convert_to_tensor(
						    [8.222_099, 7.3_534_126, 8.432_078, 7.4_402_075, 9.38_451, 6.271_159, 8.827_531, 5.4_402_995, 7.3_857_956, 9.677_023]    ,			dtype=tf.floataa    ,			)  # expected non filtered values as noted above

						a						:		Dict											=      tf_top_k_top_p_filtering(_a    ,			top_k=10    ,			top_p=0.6    ,			min_tokens_to_keep=4)

						a						:		List[Any]											=      output[output != -float("inf")]
						a						:		Optional[Any]											=      tf.cast(
						    tf.where(tf.not_equal(_a    ,			tf.constant(-float("inf")    ,			dtype=tf.floataa)))    ,			dtype=tf.intaa    ,			)

						tf.debugging.assert_near(_a    ,			_a    ,			rtol=1e-12)
						tf.debugging.assert_equal(_a    ,			_a)






@require_tf
class 						_A  (  unittest.TestCase   ,_a  ):







				"""simple docstring"""




				if is_tf_available():
								UpperCAmelCase	:							Tuple     =	{
								    '''AutoModelForCausalLM''': TFAutoModelForCausalLM,
								    '''AutoModelForSpeechSeq2Seq''': TFAutoModelForSpeechSeqaSeq,
								    '''AutoModelForSeq2SeqLM''': TFAutoModelForSeqaSeqLM,
								    '''AutoModelForVision2Seq''': TFAutoModelForVisionaSeq,
								    '''LogitsProcessorList''': TFLogitsProcessorList,
								    '''MinLengthLogitsProcessor''': TFMinLengthLogitsProcessor,
								    '''create_tensor_fn''': tf.convert_to_tensor,
								    '''floats_tensor''': floats_tensor,
								    '''return_tensors''': '''tf''',
								}






				@slow
				def      __snake_case							( self    :   int):
						# TF-only test: tf.saved_model export
						a						:		Optional[int]											=      TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2")
						a						:		Optional[int]											=      2
						a						:		Optional[Any]											=      2






						class 						_A  (  tf.Module  ):







										"""simple docstring"""




										def __init__( self    :   Optional[int]    ,			__UpperCAmelCase    :   Optional[int]):
												super(_a    ,			self).__init__()
												a						:		Union[str, Any]											=      model






										@tf.function(
										    input_signature=(
										        tf.TensorSpec((None, input_length)    ,			tf.intaa    ,			name="input_ids"),
										        tf.TensorSpec((None, input_length)    ,			tf.intaa    ,			name="attention_mask"),
										    )    ,			jit_compile=_a    ,			)
										def      __snake_case							( self    :   Union[str, Any]    ,			__UpperCAmelCase    :   str    ,			__UpperCAmelCase    :   str):
												a						:		str											=      self.model.generate(
												    input_ids=_a    ,			attention_mask=_a    ,			max_new_tokens=_a    ,			return_dict_in_generate=_a    ,			)
												return {"sequences": outputs["sequences"]}






						a						:		Dict											=      [[2, 0], [102, 103]]
						a						:		Tuple											=      [[1, 0], [1, 1]]
						a						:		Optional[int]											=      DummyModel(model=_a)
						with tempfile.TemporaryDirectory() as tmp_dir:
								tf.saved_model.save(_a    ,			_a    ,			signatures={"serving_default": dummy_model.serving})
								a						:		Dict											=      tf.saved_model.load(_a).signatures["serving_default"]
								for batch_size in range(1    ,			len(_a) + 1):
										a						:		Optional[Any]											=      {
										    "input_ids": tf.constant(dummy_input_ids[:batch_size]),
										    "attention_mask": tf.constant(dummy_attention_masks[:batch_size]),
										}
										a						:		Optional[Any]											=      serving_func(**_a)["sequences"]
										a						:		Optional[int]											=      test_model.generate(**_a    ,			max_new_tokens=_a)
										tf.debugging.assert_equal(_a    ,			_a)






				@slow
				def      __snake_case							( self    :   Optional[int]):
						# TF-only test: tf.saved_model export
						a						:		List[str]											=      TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2")
						a						:		List[Any]											=      1
						a						:		Tuple											=      2






						class 						_A  (  tf.Module  ):







										"""simple docstring"""




										def __init__( self    :   List[str]    ,			__UpperCAmelCase    :   Optional[Any]):
												super(_a    ,			self).__init__()
												a						:		str											=      model






										@tf.function(
										    input_signature=(
										        tf.TensorSpec((batch_size, None)    ,			tf.intaa    ,			name="input_ids"),
										        tf.TensorSpec((batch_size, None)    ,			tf.intaa    ,			name="attention_mask"),
										    )    ,			jit_compile=_a    ,			)
										def      __snake_case							( self    :   Dict    ,			__UpperCAmelCase    :   str    ,			__UpperCAmelCase    :   List[str]):
												a						:		Union[str, Any]											=      self.model.generate(
												    input_ids=_a    ,			attention_mask=_a    ,			max_new_tokens=_a    ,			return_dict_in_generate=_a    ,			)
												return {"sequences": outputs["sequences"]}






						a						:		Union[str, Any]											=      [[2], [102, 103]]
						a						:		Optional[int]											=      [[1], [1, 1]]
						a						:		int											=      DummyModel(model=_a)
						with tempfile.TemporaryDirectory() as tmp_dir:
								tf.saved_model.save(_a    ,			_a    ,			signatures={"serving_default": dummy_model.serving})
								a						:		int											=      tf.saved_model.load(_a).signatures["serving_default"]
								for input_row in range(len(_a)):
										a						:		int											=      {
										    "input_ids": tf.constant([dummy_input_ids[input_row]]),
										    "attention_mask": tf.constant([dummy_attention_masks[input_row]]),
										}
										a						:		Union[str, Any]											=      serving_func(**_a)["sequences"]
										a						:		Union[str, Any]											=      test_model.generate(**_a    ,			max_new_tokens=_a)
										tf.debugging.assert_equal(_a    ,			_a)






				@slow
				@require_tensorflow_text
				def      __snake_case							( self    :   Union[str, Any]):
						# TF-only test: tf.saved_model export
						with tempfile.TemporaryDirectory() as tmp_dir:
								# file needed to load the TF tokenizer
								hf_hub_download(repo_id="google/flan-t5-small"    ,			filename="spiece.model"    ,			local_dir=_a)






								class 						_A  (  tf.keras.layers.Layer  ):







												"""simple docstring"""




												def __init__( self    :   List[str]):
														super().__init__()
														a						:		Dict											=      text.SentencepieceTokenizer(
														    model=tf.io.gfile.GFile(os.path.join(_a    ,			"spiece.model")    ,			"rb").read())
														a						:		Dict											=      TFAutoModelForSeqaSeqLM.from_pretrained("hf-internal-testing/tiny-random-t5")






												def      __snake_case							( self    :   Optional[Any]    ,			__UpperCAmelCase    :   Union[str, Any]    ,			*__UpperCAmelCase    :   int    ,			**__UpperCAmelCase    :   str):
														a						:		Optional[Any]											=      self.tokenizer.tokenize(_a)
														a							,		a						:		str											=      text.pad_model_inputs(
														    _a    ,			max_seq_length=64    ,			pad_value=self.model.config.pad_token_id)
														a						:		List[str]											=      self.model.generate(input_ids=_a    ,			attention_mask=_a)
														return self.tokenizer.detokenize(_a)






								a						:		Dict											=      CompleteSentenceTransformer()
								a						:		Dict											=      tf.keras.layers.Input(shape=(1,)    ,			dtype=tf.string    ,			name="inputs")
								a						:		List[Any]											=      complete_model(_a)
								a						:		List[str]											=      tf.keras.Model(_a    ,			_a)
								keras_model.save(_a)






				def      __snake_case							( self    :   List[Any]):
						# Has PT equivalent: this test relies on random sampling
						a						:		int											=      {
						    "do_sample": True,
						    "num_beams": 1,
						    "top_p": 0.7,
						    "top_k": 10,
						    "temperature": 0.7,
						}
						a						:		Tuple											=      14

						a						:		List[Any]											=      AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-gpt2")
						a						:		int											=      "Hello, my dog is cute and"
						a						:		int											=      tokenizer(_a    ,			return_tensors="tf")
						a						:		Optional[int]											=      TFAutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-random-gpt2")

						a						:		List[str]											=      638
						# forces the generation to happen on CPU, to avoid GPU-related quirks
						with tf.device(":/CPU:0"):
								tf.random.set_seed(0)
								a						:		Tuple											=      model.generate(**_a    ,			eos_token_id=_a    ,			**_a)
						self.assertTrue(expectation == len(generated_tokens[0]))

						a						:		Dict											=      [638, 198]
						with tf.device(":/CPU:0"):
								tf.random.set_seed(0)
								a						:		Tuple											=      model.generate(**_a    ,			eos_token_id=_a    ,			**_a)
						self.assertTrue(expectation == len(generated_tokens[0]))






				def      __snake_case							( self    :   Tuple):
						# Has PT equivalent: ample use of framework-specific code
						a						:		Dict											=      AutoTokenizer.from_pretrained("hf-internal-testing/tiny-random-bart")
						a						:		str											=      "Hugging Face is a technology company based in New York and Paris."
						a						:		str											=      bart_tokenizer(_a    ,			return_tensors="tf").input_ids
						a						:		List[Any]											=      TFBartForConditionalGeneration.from_pretrained("hf-internal-testing/tiny-random-bart")
						a						:		List[str]											=      bart_model.generate(_a).numpy()






						class 						_A  (  _a  ):







										"""simple docstring"""




										def      __snake_case							( self    :   Tuple    ,			__UpperCAmelCase    :   str    ,			__UpperCAmelCase    :   Union[str, Any]=None    ,			**__UpperCAmelCase    :   str):
												return super().call(_a    ,			**_a)






						a						:		List[Any]											=      FakeBart.from_pretrained("hf-internal-testing/tiny-random-bart")
						a						:		List[Any]											=      bart_model.generate(_a    ,			foo="bar").numpy()
						self.assertTrue(np.array_equal(_a    ,			_a))






						class 						_A  (  bart_model.model.encoder.__class__  ):







										"""simple docstring"""




										def      __snake_case							( self    :   Dict    ,			__UpperCAmelCase    :   Tuple    ,			**__UpperCAmelCase    :   List[str]):
												return super().call(_a    ,			**_a)






						a						:		Any											=      FakeEncoder(bart_model.config    ,			bart_model.model.shared)
						a						:		Dict											=      fake_encoder

						# Normal generation still works (the output will be different because the encoder weights are different)
						a						:		List[str]											=      bart_model.generate(_a).numpy()
						with self.assertRaises(_a):
								# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
								bart_model.generate(_a    ,			foo="bar")










"""simple docstring"""







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 					lowercase      (    )->				Union[str, Any]:
  '''simple docstring'''







  a						:		Union[str, Any]											=      torch.nn.Linear(2  ,       4	)
  a						:		Tuple											=      torch.optim.AdamW(model.parameters()  ,       lr=1.0	)
  a						:		Union[str, Any]											=      torch.optim.lr_scheduler.OneCycleLR(A_  ,       max_lr=0.0_1  ,       steps_per_epoch=2  ,       epochs=1	)
  a						:		List[str]											=      DataLoader(TensorDataset(torch.tensor([1, 2, 3]	)	)	)
  a						:		int											=      DataLoader(TensorDataset(torch.tensor([4, 5, 6]	)	)	)

  return model, optimizer, scheduler, train_dl, valid_dl


def 					lowercase      (    A_	)->				List[Any]:
  '''simple docstring'''







  return (model.weight.abs().sum() + model.bias.abs().sum()).item()


def 					lowercase      (    A_	)->				Tuple:
  '''simple docstring'''







  a						:		Optional[int]											=      torch.nn.Linear(*tuple(model.weight.T.shape	)	).state_dict()
  model.load_state_dict(A_	)







class 						_A  (  _a  ):







    """simple docstring"""




    @require_cuda
    def      __snake_case							( self    :   Any):
      a						:		List[str]											=      Accelerator()
      assert PartialState._shared_state["_cpu"] is False
      assert PartialState._shared_state["device"].type == "cuda"
      with self.assertRaises(__UpperCAmelCase):
        a						:		Any											=      Accelerator(cpu=__UpperCAmelCase)






    def      __snake_case							( self    :   List[Any]):
      a						:		str											=      Accelerator()
      a						:		Optional[Any]											=      GradientState()
      assert state.num_steps == 1
      a						:		Dict											=      4
      assert state.num_steps == 4

      assert state.sync_gradients is True
      a						:		Optional[int]											=      False
      assert state.sync_gradients is False
      GradientState._reset_state()






    def      __snake_case							( self    :   str):
      a						:		int											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		Tuple											=      create_components()

      (
          (
          a
      )							,		(
          a
      )							,		(
          a
      )							,		(
          a
      )							,		(
          a
      )							,		
      )						:		Tuple											=      accelerator.prepare(__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase)

      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      __snake_case							( self    :   Dict):
      a						:		Dict											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		Any											=      create_components()
      accelerator.prepare(__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase)
      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      __snake_case							( self    :   int):
      PartialState._reset_state()

      # Mock torch.cuda.set_device to avoid an exception as the device doesn't exist
      def noop(*__UpperCAmelCase    :   Union[str, Any]    ,			**__UpperCAmelCase    :   Any):
        pass

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






    def      __snake_case							( self    :   List[str]):
      a						:		Tuple											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		Optional[Any]											=      create_components()
      accelerator.prepare(__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase)

      a						:		Dict											=      get_signature(__UpperCAmelCase)

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

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

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






    def      __snake_case							( self    :   Optional[int]):
      a						:		str											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		Dict											=      create_components()
      accelerator.prepare(__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase)

      a						:		Union[str, Any]											=      get_signature(__UpperCAmelCase)

      # saving hook
      def save_config(__UpperCAmelCase    :   Tuple    ,			__UpperCAmelCase    :   int    ,			__UpperCAmelCase    :   Union[str, Any]):
        a						:		Tuple											=      {"class_name": models[0].__class__.__name__}

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

        # loading hook
      def load_config(__UpperCAmelCase    :   Dict    ,			__UpperCAmelCase    :   Union[str, Any]):
        with open(os.path.join(__UpperCAmelCase    ,			"data.json")    ,			"r") as f:
          a						:		Optional[Any]											=      json.load(__UpperCAmelCase)

        a						:		Tuple											=      config["class_name"]

      a						:		Optional[int]											=      accelerator.register_save_state_pre_hook(__UpperCAmelCase)
      a						:		Tuple											=      accelerator.register_load_state_pre_hook(__UpperCAmelCase)

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

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

        # random class name to verify correct one is loaded
        a						:		int											=      "random"

        # make sure loaded weights match with hooks
        accelerator.load_state(__UpperCAmelCase)
        self.assertTrue(abs(model_signature - get_signature(__UpperCAmelCase)) < 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(__UpperCAmelCase)

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

        # random class name to verify correct one is loaded
        a						:		Dict											=      "random"

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

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






    def      __snake_case							( self    :   Optional[Any]):
      a						:		List[str]											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		int											=      create_components()
      a						:		Tuple											=      None

      # This should work
      a							,		a							,		a							,		a							,		a							,		a						:		Any											=      accelerator.prepare(
          __UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase    ,			__UpperCAmelCase)
      self.assertTrue(dummy_obj is None)






    def      __snake_case							( self    :   List[str]):
      a						:		str											=      Accelerator()
      a							,		a							,		a							,		a							,		a						:		List[Any]											=      create_components()
      a						:		Union[str, Any]											=      [1, 2, 3]

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






    @slow
    @require_bnb
    def      __snake_case							( self    :   Optional[int]):
      from transformers import AutoModelForCausalLM

      a						:		Optional[int]											=      AutoModelForCausalLM.from_pretrained(
          "EleutherAI/gpt-neo-125m"    ,			load_in_abit=__UpperCAmelCase    ,			device_map={"": 0}    ,			)
      a						:		Tuple											=      Accelerator()

      # This should work
      a						:		List[Any]											=      accelerator.prepare(__UpperCAmelCase)






    @slow
    @require_bnb
    def      __snake_case							( self    :   Optional[int]):
      from transformers import AutoModelForCausalLM

      a						:		Dict											=      Accelerator()

      with init_empty_weights():
        a						:		Any											=      AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"    ,			)
        model.tie_weights()
        a						:		Union[str, Any]											=      infer_auto_device_map(__UpperCAmelCase)
        a						:		str											=      "cpu"

      a						:		int											=      AutoModelForCausalLM.from_pretrained(
          "EleutherAI/gpt-neo-125m"    ,			device_map=__UpperCAmelCase    ,			load_in_abit=__UpperCAmelCase    ,			llm_inta_enable_fpaa_cpu_offload=__UpperCAmelCase)

      # This should not work and get value error
      with self.assertRaises(__UpperCAmelCase):
        a						:		Optional[int]											=      accelerator.prepare(__UpperCAmelCase)






    @slow
    @require_bnb
    @require_multi_gpu
    def      __snake_case							( self    :   Optional[int]):
      from transformers import AutoModelForCausalLM

      a						:		Union[str, Any]											=      {"distributed_type": DistributedType.MULTI_GPU}

      with init_empty_weights():
        a						:		List[str]											=      AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"    ,			)
        model.tie_weights()
        a						:		Any											=      infer_auto_device_map(__UpperCAmelCase)
        a						:		Dict											=      1

      a						:		Any											=      AutoModelForCausalLM.from_pretrained(
          "EleutherAI/gpt-neo-125m"    ,			load_in_abit=__UpperCAmelCase    ,			device_map=__UpperCAmelCase    ,			)
      a						:		int											=      Accelerator()

      # This should not work and get value error
      with self.assertRaises(__UpperCAmelCase):
        a						:		Optional[int]											=      accelerator.prepare(__UpperCAmelCase)

      PartialState._reset_state()






    @slow
    @require_bnb
    @require_multi_gpu
    def      __snake_case							( self    :   Tuple):
      from transformers import AutoModelForCausalLM

      with init_empty_weights():
        a						:		List[str]											=      AutoModelForCausalLM.from_pretrained(
            "EleutherAI/gpt-neo-125m"    ,			)
        a						:		Tuple											=      infer_auto_device_map(__UpperCAmelCase)
        a						:		str											=      1

      a						:		Optional[int]											=      AutoModelForCausalLM.from_pretrained(
          "EleutherAI/gpt-neo-125m"    ,			load_in_abit=__UpperCAmelCase    ,			device_map=__UpperCAmelCase    ,			)
      a						:		str											=      Accelerator()

      # This should work
      a						:		Any											=      accelerator.prepare(__UpperCAmelCase)






    @require_cuda
    def      __snake_case							( self    :   List[Any]):
      a						:		Tuple											=      torch.nn.Linear(10    ,			10)
      a						:		int											=      torch.optim.SGD(model.parameters()    ,			lr=0.01)
      a						:		Optional[Any]											=      Accelerator(cpu=__UpperCAmelCase)
      a						:		List[str]											=      accelerator.prepare(__UpperCAmelCase)






