


'''simple docstring'''






import ast
import os
import re
import shutil
import tempfile
import unittest
from unittest import mock

import torch

from accelerate.test_utils.examples import compare_against_test
from accelerate.test_utils.testing import TempDirTestCase, require_trackers, run_command, slow
from accelerate.utils import write_basic_config


# DataLoaders built from `test_samples/MRPC` for quick testing
# Should mock `{script_name}.get_dataloaders` via:
# @mock.patch("{script_name}.get_dataloaders", mocked_dataloaders)

__UpperCAmelCase       							=				[
    '''cross_validation.py''',
    '''gradient_accumulation.py''',
    '''local_sgd.py''',
    '''multi_process_metrics.py''',
    '''memory.py''',
    '''automatic_gradient_accumulation.py''',
    '''fsdp_with_peak_mem_tracking.py''',
    '''deepspeed_with_config_support.py''',
    '''megatron_lm_gpt_pretraining.py''',
]




class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_ = None   ,       lowerCamelCase_ = None  )			->				Any:
														lowerCAmelCase__			  =      None
														lowerCAmelCase__			  =      os.path.abspath(os.path.join('''examples'''   ,       '''by_feature'''  )  )
														lowerCAmelCase__			  =      os.path.abspath('''examples'''  )
														for item in os.listdir(lowerCamelCase_  ):
																					if item not in EXCLUDE_EXAMPLES:
																												lowerCAmelCase__			  =      os.path.join(lowerCamelCase_   ,       lowerCamelCase_  )
																												if os.path.isfile(lowerCamelCase_  ) and ".py" in item_path:
																																			with self.subTest(
																																			    tested_script=lowerCamelCase_   ,       feature_script=lowerCamelCase_   ,       tested_section='''main()''' if parser_only else '''training_function()'''   ,       ):
																																										lowerCAmelCase__			  =      compare_against_test(
																																										    os.path.join(lowerCamelCase_   ,       lowerCamelCase_  )   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )
																																										lowerCAmelCase__			  =      '''\n'''.join(lowerCamelCase_  )
																																										if special_strings is not None:
																																																	for string in special_strings:
																																																								lowerCAmelCase__			  =      diff.replace(lowerCamelCase_   ,       ''''''  )
																																										self.assertEqual(lowerCamelCase_   ,       ''''''  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														self.one_complete_example('''complete_nlp_example.py'''   ,       lowerCamelCase_  )
														self.one_complete_example('''complete_nlp_example.py'''   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      os.path.abspath(os.path.join('''examples'''   ,       '''cv_example.py'''  )  )
														lowerCAmelCase__			  =      [
														    ''' ''' * 16 + '''{\n\n''',
														    ''' ''' * 20 + '''"accuracy": eval_metric["accuracy"],\n\n''',
														    ''' ''' * 20 + '''"f1": eval_metric["f1"],\n\n''',
														    ''' ''' * 20 + '''"train_loss": total_loss.item() / len(train_dataloader),\n\n''',
														    ''' ''' * 20 + '''"epoch": epoch,\n\n''',
														    ''' ''' * 16 + '''},\n\n''',
														    ''' ''' * 16 + '''step=epoch,\n''',
														    ''' ''' * 12,
														    ''' ''' * 8 + '''for step, batch in enumerate(active_dataloader):\n''',
														]
														self.one_complete_example('''complete_cv_example.py'''   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )
														self.one_complete_example('''complete_cv_example.py'''   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )




@mock.patch.dict(os.environ							,							{"TESTING_MOCKED_DATALOADERS": "1"}    )
class 						a__							(				a__    ):





							'''simple docstring'''






							lowercase__     :  Optional[Any]      		= False







							@classmethod
							def     __SCREAMING_SNAKE_CASE				(						cls  )			->				Optional[Any]:
														super().setUpClass()
														lowerCAmelCase__			  =      tempfile.mkdtemp()
														lowerCAmelCase__			  =      os.path.join(cls._tmpdir   ,       '''default_config.yml'''  )

														write_basic_config(save_location=cls.configPath  )
														lowerCAmelCase__			  =      ['''accelerate''', '''launch''', '''--config_file''', cls.configPath]







							@classmethod
							def     __SCREAMING_SNAKE_CASE				(						cls  )			->				str:
														super().tearDownClass()
														shutil.rmtree(cls._tmpdir  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps epoch
        --output_dir {self.tmpdir}
        """.split()
														run_command(self._launch_args + testargs  )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir   ,       '''epoch_0'''  )  )  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      F"""
        examples/by_feature/checkpointing.py
        --checkpointing_steps 1
        --output_dir {self.tmpdir}
        """.split()
														lowerCAmelCase__			  =      run_command(self._launch_args + testargs  )
														self.assertTrue(os.path.exists(os.path.join(self.tmpdir   ,       '''step_2'''  )  )  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__			  =      F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir   ,       "epoch_0"  )}
        """.split()
														lowerCAmelCase__			  =      run_command(self._launch_args + testargs   ,       return_stdout=lowerCamelCase_  )
														self.assertNotIn('''epoch 0:'''   ,       lowerCamelCase_  )
														self.assertIn('''epoch 1:'''   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      F"""
        examples/by_feature/checkpointing.py
        --resume_from_checkpoint {os.path.join(self.tmpdir   ,       "step_2"  )}
        """.split()
														lowerCAmelCase__			  =      run_command(self._launch_args + testargs   ,       return_stdout=lowerCamelCase_  )
														if torch.cuda.is_available():
																					lowerCAmelCase__			  =      torch.cuda.device_count()
														else:
																					lowerCAmelCase__			  =      1
														if num_processes > 1:
																					self.assertNotIn('''epoch 0:'''   ,       lowerCamelCase_  )
																					self.assertIn('''epoch 1:'''   ,       lowerCamelCase_  )
														else:
																					self.assertIn('''epoch 0:'''   ,       lowerCamelCase_  )
																					self.assertIn('''epoch 1:'''   ,       lowerCamelCase_  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      '''
        examples/by_feature/cross_validation.py
        --num_folds 2
        '''.split()
														with mock.patch.dict(os.environ   ,       {'''TESTING_MOCKED_DATALOADERS''': '''0'''}  ):
																					lowerCAmelCase__			  =      run_command(self._launch_args + testargs   ,       return_stdout=lowerCamelCase_  )
																					lowerCAmelCase__			  =      re.findall('''({.+})'''   ,       lowerCamelCase_  )
																					lowerCAmelCase__			  =      [r for r in results if '''accuracy''' in r][-1]
																					lowerCAmelCase__			  =      ast.literal_eval(lowerCamelCase_  )
																					self.assertGreaterEqual(results['''accuracy''']   ,       0.75  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      ['''examples/by_feature/multi_process_metrics.py''']
														run_command(self._launch_args + testargs  )







							@require_trackers
							@mock.patch.dict(os.environ   ,       {'''WANDB_MODE''': '''offline'''}  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														with tempfile.TemporaryDirectory() as tmpdir:
																					lowerCAmelCase__			  =      F"""
            examples/by_feature/tracking.py
            --with_tracking
            --project_dir {tmpdir}
            """.split()
																					run_command(self._launch_args + testargs  )
																					self.assertTrue(os.path.exists(os.path.join(lowerCamelCase_   ,       '''tracking'''  )  )  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      ['''examples/by_feature/gradient_accumulation.py''']
														run_command(self._launch_args + testargs  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      ['''examples/by_feature/local_sgd.py''']
														run_command(self._launch_args + testargs  )


"""simple docstring"""


from statistics import mean, stdev



def   _A					(	_a	:						list     ,   _a	:						int = 3				):



      """simple docstring"""






      A				  =		min(_a				)
      A				  =		max(_a				)
      # normalize data
      return [round((x - x_min) / (x_max - x_min)     ,   _a				) for x in data]





def   _A					(	_a	:						list     ,   _a	:						int = 3				):



      """simple docstring"""






      A				  =		mean(_a				)
      A				  =		stdev(_a				)
      # standardize data
      return [round((x - mu) / (sigma)     ,   _a				) for x in data]




