


'''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)

__magic_name__ : Tuple					='bert-base-cased'
__magic_name__ : Union[str, Any]					='fp16'
__magic_name__ : Optional[int]					='bf16'
__magic_name__ : Union[str, Any]					=[FPaa, BFaa]






@require_fsdp
@require_cuda
class 		UpperCamelCase_		(       A ):





						"""simple docstring"""




						def        __A       (			self					:       List[str]	)				->       int:
										super().setUp()

										__magic_name__							=			dict(
										    ACCELERATE_USE_FSDP="true"						,					MASTER_ADDR="localhost"						,					MASTER_PORT="10999"						,					RANK="0"						,					LOCAL_RANK="0"						,					WORLD_SIZE="1"						,					)
						def        __A       (			self					:       Dict	)				->       str:
										from torch.distributed.fsdp.fully_sharded_data_parallel import ShardingStrategy

										for i, strategy in enumerate(_lowerCamelCase	):
														__magic_name__							=			self.dist_env.copy()
														__magic_name__							=			f'{i + 1}'
														__magic_name__							=			strategy
														with mockenv_context(**_lowerCamelCase	):
																		__magic_name__							=			FullyShardedDataParallelPlugin()
																		self.assertEqual(fsdp_plugin.sharding_strategy						,					ShardingStrategy(i + 1	)	)
						def        __A       (			self					:       List[Any]	)				->       Optional[int]:
										from torch.distributed.fsdp.fully_sharded_data_parallel import BackwardPrefetch

										for i, prefetch_policy in enumerate(_lowerCamelCase	):
														__magic_name__							=			self.dist_env.copy()
														__magic_name__							=			prefetch_policy
														with mockenv_context(**_lowerCamelCase	):
																		__magic_name__							=			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					:       Any	)				->       Dict:
										from torch.distributed.fsdp.fully_sharded_data_parallel import StateDictType

										for i, state_dict_type in enumerate(_lowerCamelCase	):
														__magic_name__							=			self.dist_env.copy()
														__magic_name__							=			state_dict_type
														with mockenv_context(**_lowerCamelCase	):
																		__magic_name__							=			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					:       Any	)				->       Optional[int]:
										__magic_name__							=			AutoModel.from_pretrained(_lowerCamelCase	)
										for policy in FSDP_AUTO_WRAP_POLICY:
														__magic_name__							=			self.dist_env.copy()
														__magic_name__							=			policy
														if policy == "TRANSFORMER_BASED_WRAP":
																		__magic_name__							=			'BertLayer'
														elif policy == "SIZE_BASED_WRAP":
																		__magic_name__							=			'2000'
														with mockenv_context(**_lowerCamelCase	):
																		__magic_name__							=			FullyShardedDataParallelPlugin()
																		fsdp_plugin.set_auto_wrap_policy(_lowerCamelCase	)
																		if policy == "NO_WRAP":
																						self.assertIsNone(fsdp_plugin.auto_wrap_policy	)
																		else:
																						self.assertIsNotNone(fsdp_plugin.auto_wrap_policy	)

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

										__magic_name__							=			self.dist_env.copy()
										__magic_name__							=			'SIZE_BASED_WRAP'
										__magic_name__							=			'0'
										with mockenv_context(**_lowerCamelCase	):
														__magic_name__							=			FullyShardedDataParallelPlugin()
														fsdp_plugin.set_auto_wrap_policy(_lowerCamelCase	)
														self.assertIsNone(fsdp_plugin.auto_wrap_policy	)
						def        __A       (			self					:       Optional[Any]	)				->       Optional[int]:
										from torch.distributed.fsdp.fully_sharded_data_parallel import MixedPrecision
										from torch.distributed.fsdp.sharded_grad_scaler import ShardedGradScaler

										for mp_dtype in dtypes:
														__magic_name__							=			self.dist_env.copy()
														__magic_name__							=			mp_dtype
														with mockenv_context(**_lowerCamelCase	):
																		__magic_name__							=			Accelerator()
																		if mp_dtype == "fp16":
																						__magic_name__							=			torch.floataa
																		elif mp_dtype == "bf16":
																						__magic_name__							=			torch.bfloataa
																		__magic_name__							=			MixedPrecision(param_dtype=_lowerCamelCase						,					reduce_dtype=_lowerCamelCase						,					buffer_dtype=_lowerCamelCase	)
																		self.assertEqual(accelerator.state.fsdp_plugin.mixed_precision_policy						,					_lowerCamelCase	)
																		if mp_dtype == FPaa:
																						self.assertTrue(isinstance(accelerator.scaler						,					_lowerCamelCase	)	)
																		elif mp_dtype == BFaa:
																						self.assertIsNone(accelerator.scaler	)
																		AcceleratorState._reset_state(_lowerCamelCase	)

						def        __A       (			self					:       str	)				->       int:
										from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffload

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






@require_fsdp
@require_multi_gpu
@slow
class 		UpperCamelCase_		(       A ):





						"""simple docstring"""




						def        __A       (			self					:       List[Any]	)				->       Optional[int]:
										super().setUp()
										__magic_name__							=			0.82
										__magic_name__							=			[
										    'fsdp_shard_grad_op_transformer_based_wrap',
										    'fsdp_full_shard_transformer_based_wrap',
										]
										__magic_name__							=			{
										    'multi_gpu_fp16': 32_00,
										    'fsdp_shard_grad_op_transformer_based_wrap_fp16': 20_00,
										    'fsdp_full_shard_transformer_based_wrap_fp16': 19_00,
										    # 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
										}
										__magic_name__							=			1_60
										__magic_name__							=			1_60

										__magic_name__							=			inspect.getfile(accelerate.test_utils	)
										__magic_name__							=			os.path.sep.join(mod_file.split(os.path.sep	)[:-1] + ["scripts", "external_deps"]	)
						def        __A       (			self					:       int	)				->       Optional[int]:
										__magic_name__							=			os.path.join(self.test_scripts_folder						,					"test_performance.py"	)
										__magic_name__							=			['accelerate', 'launch', '--num_processes=2', '--num_machines=1', '--machine_rank=0', '--use_fsdp']
										for config in self.performance_configs:
														__magic_name__							=			cmd.copy()
														for i, strategy in enumerate(_lowerCamelCase	):
																		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(_lowerCamelCase						,					env=os.environ.copy()	)
						def        __A       (			self					:       Tuple	)				->       Tuple:
										__magic_name__							=			os.path.join(self.test_scripts_folder						,					"test_checkpointing.py"	)
										__magic_name__							=			[
										    '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(_lowerCamelCase	):
														__magic_name__							=			cmd.copy()
														cmd_config.append(f'--fsdp_sharding_strategy={i+1}'	)
														if strategy != "FULL_SHARD":
																		continue
														__magic_name__							=			len(_lowerCamelCase	)
														for state_dict_type in FSDP_STATE_DICT_TYPE:
																		__magic_name__							=			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(_lowerCamelCase						,					env=os.environ.copy()	)

																		__magic_name__							=			cmd_config[:-1]
																		__magic_name__							=			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(_lowerCamelCase						,					env=os.environ.copy()	)

						def        __A       (			self					:       List[str]	)				->       Tuple:
										__magic_name__							=			os.path.join(self.test_scripts_folder						,					"test_peak_memory_usage.py"	)
										__magic_name__							=			[
										    '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():
														__magic_name__							=			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(_lowerCamelCase	):
																						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(_lowerCamelCase						,					env=os.environ.copy()	)









"""simple docstring"""






import qiskit







def 	_snake_case     (							lowercase__ = 2						):
				_lowerCamelCase	:     Optional[Any]       =       qubits

				# Using Aer's simulator
				_lowerCamelCase	:     Dict       =       qiskit.Aer.get_backend('aer_simulator'						)

				# Creating a Quantum Circuit acting on the q register
				_lowerCamelCase	:     Dict       =       qiskit.QuantumCircuit(lowercase__				,       lowercase__						)

				# Adding a H gate on qubit 0 (now q0 in superposition)
				circuit.h(0						)

				for i in range(1				,       lowercase__						):
								# Adding CX (CNOT) gate
								circuit.cx(i - 1				,       lowercase__						)

				# Mapping the quantum measurement to the classical bits
				circuit.measure(list(range(lowercase__						)						)				,       list(range(lowercase__						)						)						)

				# Now measuring any one qubit would affect other qubits to collapse
				# their super position and have same state as the measured one.

				# Executing the circuit on the simulator
				_lowerCamelCase	:     Optional[Any]       =       qiskit.execute(lowercase__				,       lowercase__				,       shots=1000						)

				return job.result().get_counts(lowercase__						)


if __name__ == "__main__":
			print(F"Total count for various states are: {quantum_entanglement(3)}")