






'''simple docstring'''


import os
import pickle
import unittest
from collections import UserDict, namedtuple

import torch

from accelerate.test_utils.testing import require_cuda, require_torch_min_version
from accelerate.test_utils.training import RegressionModel
from accelerate.utils import (
    convert_outputs_to_fpaa,
    extract_model_from_parallel,
    find_device,
    listify,
    patch_environment,
    recursively_apply,
    send_to_device,
)


_SCREAMING_SNAKE_CASE			=							namedtuple("ExampleNamedTuple", "a b c")

class 				lowerCAmelCase_						(						unittest.TestCase						):




 def 							_snake_case				(		self						)      ->							List[str]:
     _lowerCAmelCase		     = torch.randn(5     ,       2						)
     _lowerCAmelCase		     = torch.device("cuda"						) if torch.cuda.is_available() else torch.device("cpu"						)

     _lowerCAmelCase		     = send_to_device(_UpperCAmelCase     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta.cpu()     ,       _UpperCAmelCase						)						)

     _lowerCAmelCase		     = send_to_device((tensor, [tensor, tensor], 1)     ,       _UpperCAmelCase						)
     self.assertIsInstance(_UpperCAmelCase     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta[0].cpu()     ,       _UpperCAmelCase						)						)
     self.assertIsInstance(resulta[1]     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta[1][0].cpu()     ,       _UpperCAmelCase						)						)
     self.assertTrue(torch.equal(resulta[1][1].cpu()     ,       _UpperCAmelCase						)						)
     self.assertEqual(resulta[2]     ,       1						)

     _lowerCAmelCase		     = send_to_device({"a": tensor, "b": [tensor, tensor], "c": 1}     ,       _UpperCAmelCase						)
     self.assertIsInstance(_UpperCAmelCase     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta["a"].cpu()     ,       _UpperCAmelCase						)						)
     self.assertIsInstance(resulta["b"]     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta["b"][0].cpu()     ,       _UpperCAmelCase						)						)
     self.assertTrue(torch.equal(resulta["b"][1].cpu()     ,       _UpperCAmelCase						)						)
     self.assertEqual(resulta["c"]     ,       1						)

     _lowerCAmelCase		     = send_to_device(ExampleNamedTuple(a=_UpperCAmelCase     ,       b=[tensor, tensor]     ,       c=1						)     ,       _UpperCAmelCase						)
     self.assertIsInstance(_UpperCAmelCase     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta.a.cpu()     ,       _UpperCAmelCase						)						)
     self.assertIsInstance(resulta.b     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta.b[0].cpu()     ,       _UpperCAmelCase						)						)
     self.assertTrue(torch.equal(resulta.b[1].cpu()     ,       _UpperCAmelCase						)						)
     self.assertEqual(resulta.c     ,       1						)

     _lowerCAmelCase		     = send_to_device(UserDict({"a": tensor, "b": [tensor, tensor], "c": 1}						)     ,       _UpperCAmelCase						)
     self.assertIsInstance(_UpperCAmelCase     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta["a"].cpu()     ,       _UpperCAmelCase						)						)
     self.assertIsInstance(resulta["b"]     ,       _UpperCAmelCase						)
     self.assertTrue(torch.equal(resulta["b"][0].cpu()     ,       _UpperCAmelCase						)						)
     self.assertTrue(torch.equal(resulta["b"][1].cpu()     ,       _UpperCAmelCase						)						)
     self.assertEqual(resulta["c"]     ,       1						)




 def 							_snake_case				(		self						)      ->							List[Any]:


     with self.assertRaises(_UpperCAmelCase						) as cm:
         _lowerCAmelCase		     = recursively_apply(torch.tensor     ,       (torch.tensor(1						), 1)     ,       error_on_other_type=_UpperCAmelCase						)
     self.assertEqual(
         str(cm.exception						)     ,       "Unsupported types (<class \'int\'>) passed to `tensor`. Only nested list/tuple/dicts of objects that are valid for `is_torch_tensor` should be passed."     ,       )




 def 							_snake_case				(		self						)      ->							Dict:
     _lowerCAmelCase		     = torch.tensor([1, 2, 3, 4, 5]						)
     self.assertEqual(listify(_UpperCAmelCase						)     ,       [1, 2, 3, 4, 5]						)

     _lowerCAmelCase		     = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]						)
     self.assertEqual(listify(_UpperCAmelCase						)     ,       [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]						)

     _lowerCAmelCase		     = torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]						)
     self.assertEqual(
         listify(_UpperCAmelCase						)     ,       [[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]						)




 def 							_snake_case				(		self						)      ->							str:


     with patch_environment(aa=1     ,       BB=2						):
         self.assertEqual(os.environ.get("AA"						)     ,       "1"						)
         self.assertEqual(os.environ.get("BB"						)     ,       "2"						)

     self.assertNotIn("AA"     ,       os.environ						)
     self.assertNotIn("BB"     ,       os.environ						)




 def 							_snake_case				(		self						)      ->							List[Any]:
     _lowerCAmelCase		     = RegressionModel()
     _lowerCAmelCase		     = model.forward
     _lowerCAmelCase		     = convert_outputs_to_fpaa(model.forward						)
     _lowerCAmelCase		     = extract_model_from_parallel(_UpperCAmelCase     ,       keep_fpaa_wrapper=_UpperCAmelCase						)
     _lowerCAmelCase		     = pickle.dumps(_UpperCAmelCase						)




 @require_cuda
 def 							_snake_case				(		self						)      ->							List[Any]:
     _lowerCAmelCase		     = RegressionModel()
     _lowerCAmelCase		     = model.forward
     _lowerCAmelCase		     = torch.cuda.amp.autocast(dtype=torch.floataa						)(model.forward						)
     _lowerCAmelCase		     = convert_outputs_to_fpaa(model.forward						)
     _lowerCAmelCase		     = extract_model_from_parallel(_UpperCAmelCase     ,       keep_fpaa_wrapper=_UpperCAmelCase						)
     _lowerCAmelCase		     = pickle.dumps(_UpperCAmelCase						)




 @require_cuda
 @require_torch_min_version(version="2.0"						)
 def 							_snake_case				(		self						)      ->							Union[str, Any]:
     _lowerCAmelCase		     = RegressionModel()
     _lowerCAmelCase		     = model.forward
     _lowerCAmelCase		     = torch.cuda.amp.autocast(dtype=torch.floataa						)(model.forward						)
     _lowerCAmelCase		     = convert_outputs_to_fpaa(model.forward						)
     _lowerCAmelCase		     = torch.compile(model.forward     ,       backend="inductor"						)
     _lowerCAmelCase		     = torch.randn(4     ,       10						).cuda()
     _lowerCAmelCase		     = model(_UpperCAmelCase						)




 def 							_snake_case				(		self						)      ->							str:
     _lowerCAmelCase		     = RegressionModel()
     # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
     _lowerCAmelCase		     = torch.nn.parallel.DataParallel(_UpperCAmelCase						)
     _lowerCAmelCase		     = extract_model_from_parallel(_UpperCAmelCase						)

     self.assertEqual(_UpperCAmelCase     ,       _UpperCAmelCase						)




 @require_torch_min_version(version="2.0"						)
 def 							_snake_case				(		self						)      ->							Any:
     _lowerCAmelCase		     = RegressionModel()
     _lowerCAmelCase		     = torch.compile(_UpperCAmelCase						)

     # could also do a test with DistributedDataParallel, but difficult to run on CPU or single GPU
     _lowerCAmelCase		     = torch.nn.parallel.DataParallel(_UpperCAmelCase						)
     _lowerCAmelCase		     = torch.compile(_UpperCAmelCase						)
     _lowerCAmelCase		     = extract_model_from_parallel(_UpperCAmelCase						)

     self.assertEqual(compiled_model._orig_mod     ,       compiled_model_unwrapped._orig_mod						)





 def 							_snake_case				(		self						)      ->							Dict:
     self.assertEqual(find_device([1, "a", torch.tensor([1, 2, 3]						)]						)     ,       torch.device("cpu"						)						)
     self.assertEqual(find_device({"a": 1, "b": torch.tensor([1, 2, 3]						)}						)     ,       torch.device("cpu"						)						)
     self.assertIsNone(find_device([1, "a"]						)						)









'''simple docstring'''


def 		__a(SCREAMING_SNAKE_CASE_					:   List[Any]						,    SCREAMING_SNAKE_CASE_					:   str      ):



    '''simple docstring'''





    if n < 0:
        return 0
    # table[i] represents the number of ways to get to amount i
    _lowerCAmelCase		     = [0] * (n + 1)

    # There is exactly 1 way to get to zero(You pick no coins).
    _lowerCAmelCase		     = 1

    # Pick all coins one by one and update table[] values
    # after the index greater than or equal to the value of the
    # picked coin
    for coin_val in s:
        for j in range(SCREAMING_SNAKE_CASE_						,    n + 1      ):
            table[j] += table[j - coin_val]

    return table[n]


if __name__ == "__main__":
       import doctest

       doctest.testmod()


