'''simple docstring'''




import inspect
import os

import torch
from transformers import AutoModel
from transformers.testing_utils import mockenv_context
from transformers.trainer_utils import set_seed

import accelerate
from accelerate.accelerator import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils.testing import (
    AccelerateTestCase,
    TempDirTestCase,
    execute_subprocess_async,
    require_cuda,
    require_fsdp,
    require_multi_gpu,
    slow,
)
from accelerate.utils.constants import (
    FSDP_AUTO_WRAP_POLICY,
    FSDP_BACKWARD_PREFETCH,
    FSDP_SHARDING_STRATEGY,
    FSDP_STATE_DICT_TYPE,
)
from accelerate.utils.dataclasses import FullyShardedDataParallelPlugin
from accelerate.utils.other import patch_environment


set_seed(42)

__SCREAMING_SNAKE_CASE       :     Any     =  """bert-base-cased"""
__SCREAMING_SNAKE_CASE       :     Any     =  """fp16"""
__SCREAMING_SNAKE_CASE       :     Optional[Any]     =  """bf16"""
__SCREAMING_SNAKE_CASE       :     Dict     =  [FPaa, BFaa]

@require_fsdp
@require_cuda
class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      def      _A	(       self						:				Union[str, Any]       ):
             super().setUp()

             _UpperCAmelCase     :  Optional[int]							      =    dict(
                 ACCELERATE_USE_FSDP="true"						,					MASTER_ADDR="localhost"						,					MASTER_PORT="10999"						,					RANK="0"						,					LOCAL_RANK="0"						,					WORLD_SIZE="1"						,					)




      def      _A	(       self						:				Optional[Any]       ):
             from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy

             for i, strategy in enumerate(A       ):
                    _UpperCAmelCase     :  Union[str, Any]							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  Any							      =    F"""{i + 1}"""
                    _UpperCAmelCase     :  str							      =    strategy
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  Any							      =    FullyShardedDataParallelPlugin()
                           self.assertEqual(fsdp_plugin.sharding_strategy						,					ShardingStrategy(i + 1       )       )




      def      _A	(       self						:				Any       ):
             from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch

             for i, prefetch_policy in enumerate(A       ):
                    _UpperCAmelCase     :  Union[str, Any]							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  Optional[Any]							      =    prefetch_policy
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  Union[str, Any]							      =    FullyShardedDataParallelPlugin()
                           if prefetch_policy == "NO_PREFETCH":
                                  self.assertIsNone(fsdp_plugin.backward_prefetch       )
                           else:
                                  self.assertEqual(fsdp_plugin.backward_prefetch						,					BackwardPrefetch(i + 1       )       )




      def      _A	(       self						:				int       ):
             from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType

             for i, state_dict_type in enumerate(A       ):
                    _UpperCAmelCase     :  Optional[int]							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  Tuple							      =    state_dict_type
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  List[str]							      =    FullyShardedDataParallelPlugin()
                           self.assertEqual(fsdp_plugin.state_dict_type						,					StateDictType(i + 1       )       )
                           if state_dict_type == "FULL_STATE_DICT":
                                  self.assertTrue(fsdp_plugin.state_dict_config.offload_to_cpu       )
                                  self.assertTrue(fsdp_plugin.state_dict_config.ranka_only       )




      def      _A	(       self						:				List[str]       ):
             _UpperCAmelCase     :  List[str]							      =    AutoModel.from_pretrained(A       )
             for policy in FSDP_AUTO_WRAP_POLICY:
                    _UpperCAmelCase     :  Any							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  Optional[int]							      =    policy
                    if policy == "TRANSFORMER_BASED_WRAP":
                           _UpperCAmelCase     :  Optional[Any]							      =    "BertLayer"
                    elif policy == "SIZE_BASED_WRAP":
                           _UpperCAmelCase     :  Any							      =    "2000"
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  List[Any]							      =    FullyShardedDataParallelPlugin()
                           fsdp_plugin.set_auto_wrap_policy(A       )
                           if policy == "NO_WRAP":
                                  self.assertIsNone(fsdp_plugin.auto_wrap_policy       )
                           else:
                                  self.assertIsNotNone(fsdp_plugin.auto_wrap_policy       )

             _UpperCAmelCase     :  Any							      =    self.dist_env.copy()
             _UpperCAmelCase     :  Tuple							      =    "TRANSFORMER_BASED_WRAP"
             _UpperCAmelCase     :  Tuple							      =    "T5Layer"
             with mockenv_context(**A       ):
                    _UpperCAmelCase     :  Dict							      =    FullyShardedDataParallelPlugin()
                    with self.assertRaises(A       ) as cm:
                           fsdp_plugin.set_auto_wrap_policy(A       )
                    self.assertTrue("Could not find the transformer layer class to wrap in the model." in str(cm.exception       )       )

             _UpperCAmelCase     :  str							      =    self.dist_env.copy()
             _UpperCAmelCase     :  Optional[int]							      =    "SIZE_BASED_WRAP"
             _UpperCAmelCase     :  List[str]							      =    "0"
             with mockenv_context(**A       ):
                    _UpperCAmelCase     :  List[Any]							      =    FullyShardedDataParallelPlugin()
                    fsdp_plugin.set_auto_wrap_policy(A       )
                    self.assertIsNone(fsdp_plugin.auto_wrap_policy       )




      def      _A	(       self						:				List[str]       ):
             from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
             from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler

             for mp_dtype in dtypes:
                    _UpperCAmelCase     :  str							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  str							      =    mp_dtype
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  int							      =    Accelerator()
                           if mp_dtype == "fp16":
                                  _UpperCAmelCase     :  Union[str, Any]							      =    torch.floataa
                           elif mp_dtype == "bf16":
                                  _UpperCAmelCase     :  Union[str, Any]							      =    torch.bfloataa
                           _UpperCAmelCase     :  Optional[int]							      =    MixedPrecision(param_dtype=A						,					reduce_dtype=A						,					buffer_dtype=A       )
                           self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy						,					A       )
                           if mp_dtype == FPaa:
                                  self.assertTrue(isinstance(accelerator.scaler						,					A       )       )
                           elif mp_dtype == BFaa:
                                  self.assertIsNone(accelerator.scaler       )
                           AcceleratorState._reset_state(A       )





      def      _A	(       self						:				Optional[Any]       ):
             from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload

             for flag in [True, False]:
                    _UpperCAmelCase     :  str							      =    self.dist_env.copy()
                    _UpperCAmelCase     :  Dict							      =    str(A       ).lower()
                    with mockenv_context(**A       ):
                           _UpperCAmelCase     :  Tuple							      =    FullyShardedDataParallelPlugin()
                           self.assertEqual(fsdp_plugin.cpu_offload						,					CPUOffload(offload_params=A       )       )

@require_fsdp
@require_multi_gpu
@slow
class 	lowerCamelCase_	(snake_case__    ):
      '''simple docstring'''

      def      _A	(       self						:				List[Any]       ):
             super().setUp()
             _UpperCAmelCase     :  Optional[int]							      =    0.82
             _UpperCAmelCase     :  int							      =    [
                 "fsdp_shard_grad_op_transformer_based_wrap",
                 "fsdp_full_shard_transformer_based_wrap",
             ]
             _UpperCAmelCase     :  Tuple							      =    {
                 "multi_gpu_fp16": 3200,
                 "fsdp_shard_grad_op_transformer_based_wrap_fp16": 2000,
                 "fsdp_full_shard_transformer_based_wrap_fp16": 1900,
                 # Disabling below test as it overwhelms the RAM memory usage
                 # on CI self-hosted runner leading to tests getting killed.
                 # "fsdp_full_shard_cpu_offload_transformer_based_wrap_fp32": 1500,  # fp16 was leading to indefinite hang
             }
             _UpperCAmelCase     :  Tuple							      =    160
             _UpperCAmelCase     :  Any							      =    160

             _UpperCAmelCase     :  List[str]							      =    inspect.getfile(accelerate.test_utils       )
             _UpperCAmelCase     :  int							      =    os.path.sep.join(mod_file.split(os.path.sep       )[:-1] + ["scripts", "external_deps"]       )




      def      _A	(       self						:				Optional[Any]       ):
             _UpperCAmelCase     :  Union[str, Any]							      =    os.path.join(self.test_scripts_folder						,					"test_performance.py"       )
             _UpperCAmelCase     :  Optional[int]							      =    ["accelerate", "launch", "--num_processes=2", "--num_machines=1", "--machine_rank=0", "--use_fsdp"]
             for config in self.performance_configs:
                    _UpperCAmelCase     :  Tuple							      =    cmd.copy()
                    for i, strategy in enumerate(A       ):
                           if strategy.lower() in config:
                                  cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
                                  break

                    if "fp32" in config:
                           cmd_config.append("--mixed_precision=no"       )
                    else:
                           cmd_config.append("--mixed_precision=fp16"       )

                    if "cpu_offload" in config:
                           cmd_config.append("--fsdp_offload_params=True"       )

                    for policy in FSDP_AUTO_WRAP_POLICY:
                           if policy.lower() in config:
                                  cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}"""       )
                                  break

                    if policy == "TRANSFORMER_BASED_WRAP":
                           cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer"       )
                    elif policy == "SIZE_BASED_WRAP":
                           cmd_config.append("--fsdp_min_num_params=2000"       )

                    cmd_config.extend(
                        [
                            self.test_file_path,
                            F"""--output_dir={self.tmpdir}""",
                            F"""--performance_lower_bound={self.performance_lower_bound}""",
                        ]       )
                    with patch_environment(omp_num_threads=1       ):
                           execute_subprocess_async(A						,					env=os.environ.copy()       )




      def      _A	(       self						:				List[Any]       ):
             _UpperCAmelCase     :  Dict							      =    os.path.join(self.test_scripts_folder						,					"test_checkpointing.py"       )
             _UpperCAmelCase     :  Union[str, Any]							      =    [
                 "accelerate",
                 "launch",
                 "--num_processes=2",
                 "--num_machines=1",
                 "--machine_rank=0",
                 "--use_fsdp",
                 "--mixed_precision=fp16",
                 "--fsdp_transformer_layer_cls_to_wrap=BertLayer",
             ]

             for i, strategy in enumerate(A       ):
                    _UpperCAmelCase     :  Optional[Any]							      =    cmd.copy()
                    cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
                    if strategy != "FULL_SHARD":
                           continue
                    _UpperCAmelCase     :  Optional[Any]							      =    len(A       )
                    for state_dict_type in FSDP_STATE_DICT_TYPE:
                           _UpperCAmelCase     :  Optional[Any]							      =    cmd_config[:state_dict_config_index]
                           cmd_config.append(F"""--fsdp_state_dict_type={state_dict_type}"""       )
                           cmd_config.extend(
                               [
                                   self.test_file_path,
                                   F"""--output_dir={self.tmpdir}""",
                                   "--partial_train_epoch=1",
                               ]       )
                           with patch_environment(omp_num_threads=1       ):
                                  execute_subprocess_async(A						,					env=os.environ.copy()       )

                           _UpperCAmelCase     :  Optional[int]							      =    cmd_config[:-1]
                           _UpperCAmelCase     :  List[str]							      =    os.path.join(self.tmpdir						,					"epoch_0"       )
                           cmd_config.extend(
                               [
                                   F"""--resume_from_checkpoint={resume_from_checkpoint}""",
                               ]       )
                           with patch_environment(omp_num_threads=1       ):
                                  execute_subprocess_async(A						,					env=os.environ.copy()       )





      def      _A	(       self						:				List[Any]       ):
             _UpperCAmelCase     :  str							      =    os.path.join(self.test_scripts_folder						,					"test_peak_memory_usage.py"       )
             _UpperCAmelCase     :  Tuple							      =    [
                 "accelerate",
                 "launch",
                 "--num_processes=2",
                 "--num_machines=1",
                 "--machine_rank=0",
             ]
             for spec, peak_mem_upper_bound in self.peak_memory_usage_upper_bound.items():
                    _UpperCAmelCase     :  str							      =    cmd.copy()
                    if "fp16" in spec:
                           cmd_config.extend(["--mixed_precision=fp16"]       )
                    else:
                           cmd_config.extend(["--mixed_precision=no"]       )

                    if "multi_gpu" in spec:
                           continue
                    else:
                           cmd_config.extend(["--use_fsdp"]       )
                           for i, strategy in enumerate(A       ):
                                  if strategy.lower() in spec:
                                         cmd_config.append(F"""--fsdp_sharding_strategy={i+1}"""       )
                                         break

                           if "cpu_offload" in spec:
                                  cmd_config.append("--fsdp_offload_params=True"       )

                           for policy in FSDP_AUTO_WRAP_POLICY:
                                  if policy.lower() in spec:
                                         cmd_config.append(F"""--fsdp_auto_wrap_policy={policy}"""       )
                                         break

                           if policy == "TRANSFORMER_BASED_WRAP":
                                  cmd_config.append("--fsdp_transformer_layer_cls_to_wrap=BertLayer"       )
                           elif policy == "SIZE_BASED_WRAP":
                                  cmd_config.append("--fsdp_min_num_params=2000"       )

                    cmd_config.extend(
                        [
                            self.test_file_path,
                            F"""--output_dir={self.tmpdir}""",
                            F"""--peak_memory_upper_bound={peak_mem_upper_bound}""",
                            F"""--n_train={self.n_train}""",
                            F"""--n_val={self.n_val}""",
                        ]       )
                    with patch_environment(omp_num_threads=1       ):
                           execute_subprocess_async(A						,					env=os.environ.copy()       )






import json
import os
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers.testing_utils import require_torch, require_vision, slow
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
    import torch

if is_vision_available():
    from PIL import Image

    from transformers import ImageGPTImageProcessor



class 				lowerCAmelCase_		(  unittest.TestCase							):
       def __init__(			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=7,			SCREAMING_SNAKE_CASE_=3,			SCREAMING_SNAKE_CASE_=18,			SCREAMING_SNAKE_CASE_=30,			SCREAMING_SNAKE_CASE_=400,			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=None,			SCREAMING_SNAKE_CASE_=True,			)     ->		Union[str, Any]:
          UpperCamelCase    :  str							=	size if size is not None else {'height': 18, 'width': 18}
          UpperCamelCase    :  int							=	parent
          UpperCamelCase    :  List[Any]							=	batch_size
          UpperCamelCase    :  int							=	num_channels
          UpperCamelCase    :  Any							=	image_size
          UpperCamelCase    :  Optional[int]							=	min_resolution
          UpperCamelCase    :  Optional[Any]							=	max_resolution
          UpperCamelCase    :  Union[str, Any]							=	do_resize
          UpperCamelCase    :  List[Any]							=	size
          UpperCamelCase    :  int							=	do_normalize






       def 					snake_case_       (			self       )     ->		Tuple:
          return {
              # here we create 2 clusters for the sake of simplicity
              "clusters": np.asarray(
                  [
                      [0.88_66_44_36_34_03_32_03, 0.66_18_82_93_69_54_49_83, 0.38_91_74_64_01_78_68_04],
                      [-0.60_42_55_91_46_88_11_04, -0.0_22_95_00_88_60_52_84_69, 0.54_23_79_73_69_00_32_96],
                  ]       ),
              "do_resize": self.do_resize,
              "size": self.size,
              "do_normalize": self.do_normalize,
          }






@require_torch
@require_vision
class 				lowerCAmelCase_		(  a__       ,    unittest.TestCase							):
       UpperCAmelCase__				:					Any        =  ImageGPTImageProcessor if is_vision_available() else None
       def 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  str							=	ImageGPTImageProcessingTester(self       )
       @property
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          return self.image_processor_tester.prepare_image_processor_dict()
       def 					snake_case_       (			self       )     ->		str:
          UpperCamelCase    :  int							=	self.image_processing_class(**self.image_processor_dict       )
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,			'clusters'       )       )
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,			'do_resize'       )       )
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,			'size'       )       )
          self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,			'do_normalize'       )       )
       def 					snake_case_       (			self       )     ->		str:
          UpperCamelCase    :  Tuple							=	self.image_processing_class.from_dict(self.image_processor_dict       )
          self.assertEqual(image_processor.size,			{'height': 18, 'width': 18}       )

          UpperCamelCase    :  Dict							=	self.image_processing_class.from_dict(self.image_processor_dict,			size=42       )
          self.assertEqual(image_processor.size,			{'height': 42, 'width': 42}       )
       def 					snake_case_       (			self       )     ->		List[str]:
          UpperCamelCase    :  str							=	self.image_processing_class(**self.image_processor_dict       )
          UpperCamelCase    :  int							=	json.loads(image_processor.to_json_string()       )
          for key, value in self.image_processor_dict.items():
             if key == "clusters":
                self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE_,			obj[key]       )       )
             else:
                self.assertEqual(obj[key],			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Dict:
          UpperCamelCase    :  Tuple							=	self.image_processing_class(**self.image_processor_dict       )

          with tempfile.TemporaryDirectory() as tmpdirname:
             UpperCamelCase    :  List[str]							=	os.path.join(SCREAMING_SNAKE_CASE_,			'image_processor.json'       )
             image_processor_first.to_json_file(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Tuple							=	self.image_processing_class.from_json_file(SCREAMING_SNAKE_CASE_       ).to_dict()

          UpperCamelCase    :  List[Any]							=	image_processor_first.to_dict()
          for key, value in image_processor_first.items():
             if key == "clusters":
                self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE_,			image_processor_second[key]       )       )
             else:
                self.assertEqual(image_processor_first[key],			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Optional[int]:
          UpperCamelCase    :  Optional[Any]							=	self.image_processing_class(**self.image_processor_dict       )

          with tempfile.TemporaryDirectory() as tmpdirname:
             image_processor_first.save_pretrained(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  str							=	self.image_processing_class.from_pretrained(SCREAMING_SNAKE_CASE_       ).to_dict()

          UpperCamelCase    :  Union[str, Any]							=	image_processor_first.to_dict()
          for key, value in image_processor_first.items():
             if key == "clusters":
                self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE_,			image_processor_second[key]       )       )
             else:
                self.assertEqual(image_processor_first[key],			SCREAMING_SNAKE_CASE_       )






       @unittest.skip('ImageGPT requires clusters at initialization'       )
       def 					snake_case_       (			self       )     ->		str:
          pass






def 		UpperCamelCase	(   )	->     int:
   UpperCamelCase    :  Optional[int]							=	load_dataset('hf-internal-testing/fixtures_image_utils'       ,     split='test'	)

   UpperCamelCase    :  int							=	Image.open(dataset[4]['file']	)
   UpperCamelCase    :  Optional[Any]							=	Image.open(dataset[5]['file']	)

   UpperCamelCase    :  str							=	[imagea, imagea]

   return images



@require_vision
@require_torch
class 				lowerCAmelCase_		(  unittest.TestCase							):
       @slow
       def 					snake_case_       (			self       )     ->		str:
          UpperCamelCase    :  List[str]							=	ImageGPTImageProcessor.from_pretrained('openai/imagegpt-small'       )

          UpperCamelCase    :  List[str]							=	prepare_images()

          # test non-batched
          UpperCamelCase    :  int							=	image_processing(images[0],			return_tensors='pt'       )

          self.assertIsInstance(encoding.input_ids,			torch.LongTensor       )
          self.assertEqual(encoding.input_ids.shape,			(1, 1024)       )

          UpperCamelCase    :  Union[str, Any]							=	[306, 191, 191]
          self.assertEqual(encoding.input_ids[0, :3].tolist(),			SCREAMING_SNAKE_CASE_       )

          # test batched
          UpperCamelCase    :  Tuple							=	image_processing(SCREAMING_SNAKE_CASE_,			return_tensors='pt'       )

          self.assertIsInstance(encoding.input_ids,			torch.LongTensor       )
          self.assertEqual(encoding.input_ids.shape,			(2, 1024)       )

          UpperCamelCase    :  Optional[Any]							=	[303, 13, 13]
          self.assertEqual(encoding.input_ids[1, -3:].tolist(),			SCREAMING_SNAKE_CASE_       )



