
import warnings
from dataclasses import dataclass, field
from typing import Optional, Tuple

from .training_args import TrainingArguments
from .utils import cached_property, is_tf_available, logging, requires_backends


lowercase__							:							Tuple													=     logging.get_logger(__name__)

if is_tf_available():
				import tensorflow as tf






@dataclass
class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							_snake_case       						=					'tf'
							_snake_case       						=					field(
							    default=SCREAMING_SNAKE_CASE_				,						metadata={'help': 'Name of TPU'}				,						)

							_snake_case       						=					field(
							    default=SCREAMING_SNAKE_CASE_				,						metadata={'help': 'Zone of TPU'}				,						)

							_snake_case       						=					field(
							    default=SCREAMING_SNAKE_CASE_				,						metadata={'help': 'Name of Cloud TPU-enabled project'}				,						)

							_snake_case       						=					field(
							    default=1.0				,						metadata={'help': 'Power for the Polynomial decay LR scheduler.'}				,						)

							_snake_case       						=					field(default=SCREAMING_SNAKE_CASE_				,						metadata={'help': 'Whether to activate the XLA compilation or not'}      )



							@cached_property
							def       A__						(					self     )->				Tuple["tf.distribute.Strategy", int]:





													'''simple docstring'''






													requires_backends(self       ,		['''tf''']     )
													logger.info('''Tensorflow: setting up strategy'''     )

													__UpperCamelCase       					=     tf.config.list_physical_devices('''GPU'''     )

													# Set to float16 at first
													if self.fpaa:
																			tf.keras.mixed_precision.set_global_policy('''mixed_float16'''     )

													if self.no_cuda:
																			__UpperCamelCase       					=     tf.distribute.OneDeviceStrategy(device='''/cpu:0'''     )
													else:
																			try:
																									if self.tpu_name:
																															__UpperCamelCase       					=     tf.distribute.cluster_resolver.TPUClusterResolver(
																															    self.tpu_name       ,		zone=self.tpu_zone       ,		project=self.gcp_project     )
																									else:
																															__UpperCamelCase       					=     tf.distribute.cluster_resolver.TPUClusterResolver()
																			except ValueError:
																									if self.tpu_name:
																															raise RuntimeError(F"Couldn't connect to TPU {self.tpu_name}!"     )
																									else:
																															__UpperCamelCase       					=     None

																			if tpu:
																									# Set to bfloat16 in case of TPU
																									if self.fpaa:
																															tf.keras.mixed_precision.set_global_policy('''mixed_bfloat16'''     )

																									tf.config.experimental_connect_to_cluster(SCREAMING_SNAKE_CASE_     )
																									tf.tpu.experimental.initialize_tpu_system(SCREAMING_SNAKE_CASE_     )

																									__UpperCamelCase       					=     tf.distribute.TPUStrategy(SCREAMING_SNAKE_CASE_     )

																			elif len(SCREAMING_SNAKE_CASE_     ) == 0:
																									__UpperCamelCase       					=     tf.distribute.OneDeviceStrategy(device='''/cpu:0'''     )
																			elif len(SCREAMING_SNAKE_CASE_     ) == 1:
																									__UpperCamelCase       					=     tf.distribute.OneDeviceStrategy(device='''/gpu:0'''     )
																			elif len(SCREAMING_SNAKE_CASE_     ) > 1:
																									# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																									__UpperCamelCase       					=     tf.distribute.MirroredStrategy()
																			else:
																									raise ValueError('''Cannot find the proper strategy, please check your environment properties.'''     )

													return strategy



							@property
							def       A__						(					self     )->				"tf.distribute.Strategy":





													'''simple docstring'''






													requires_backends(self       ,		['''tf''']     )
													return self._setup_strategy



							@property
							def       A__						(					self     )->				int:





													'''simple docstring'''






													requires_backends(self       ,		['''tf''']     )
													return self._setup_strategy.num_replicas_in_sync



							@property
							def       A__						(					self     )->				str:





													'''simple docstring'''






													return False  # TF Logging is handled by Keras not the Trainer



							@property
							def       A__						(					self     )->				int:





													'''simple docstring'''






													if self.per_gpu_train_batch_size:
																			logger.warning(
																			    '''Using deprecated `--per_gpu_train_batch_size` argument which will be removed in a future '''
																			    '''version. Using `--per_device_train_batch_size` is preferred.'''     )
													__UpperCamelCase       					=     self.per_gpu_train_batch_size or self.per_device_train_batch_size
													return per_device_batch_size * self.n_replicas



							@property
							def       A__						(					self     )->				int:





													'''simple docstring'''






													if self.per_gpu_eval_batch_size:
																			logger.warning(
																			    '''Using deprecated `--per_gpu_eval_batch_size` argument which will be removed in a future '''
																			    '''version. Using `--per_device_eval_batch_size` is preferred.'''     )
													__UpperCamelCase       					=     self.per_gpu_eval_batch_size or self.per_device_eval_batch_size
													return per_device_batch_size * self.n_replicas



							@property
							def       A__						(					self     )->				int:





													'''simple docstring'''






													requires_backends(self       ,		['''tf''']     )
													warnings.warn(
													    '''The n_gpu argument is deprecated and will be removed in a future version, use n_replicas instead.'''       ,		SCREAMING_SNAKE_CASE_       ,		)
													return self._setup_strategy.num_replicas_in_sync






import json
import os
from collections.abc import Mapping
from typing import Dict, List, Optional, Union

import numpy as np
import torch

from .imports import is_safetensors_available




def 		A_	(							snake_case							:				Union[str, Any]	, snake_case							:				str	, snake_case							:				Dict	, snake_case							:				Optional[Any]=None	) ->      Optional[Any]:



						'''simple docstring'''

						__UpperCamelCase       					=     None
						# Check the string instead of the dtype to be compatible with versions of PyTorch that don't have bfloat16.
						if str(weight.dtype	) == "torch.bfloat16":
												# Need to reinterpret the underlined data as int16 since NumPy does not handle bfloat16s.
												__UpperCamelCase       					=     weight.view(torch.intaa	)
												__UpperCamelCase       					=     '''bfloat16'''
						__UpperCamelCase       					=     weight.cpu().numpy()
						__UpperCamelCase       					=     os.path.join(snake_case	, f"{weight_name}.dat"	)
						if index is not None:
												if dtype is None:
																		__UpperCamelCase       					=     str(array.dtype	)
												__UpperCamelCase       					=     {'''dtype''': dtype, '''shape''': list(array.shape	)}
						if array.ndim == 0:
												__UpperCamelCase       					=     array[None]
						__UpperCamelCase       					=     np.memmap(snake_case	, dtype=array.dtype	, mode='''w+'''	, shape=array.shape	)
						__UpperCamelCase       					=     array[:]
						file_array.flush()
						return index




def 		A_	(							snake_case							:				Tuple	, snake_case							:				Union[str, Any]	) ->      Dict:



						'''simple docstring'''

						__UpperCamelCase       					=     tuple(weight_info['''shape''']	)
						if shape == ():
												# NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
												__UpperCamelCase       					=     (1,)

						__UpperCamelCase       					=     weight_info['''dtype''']
						if dtype == "bfloat16":
												# NumPy does not support bfloat16 so this was saved as a int16
												__UpperCamelCase       					=     '''int16'''

						__UpperCamelCase       					=     np.memmap(snake_case	, dtype=snake_case	, shape=snake_case	, mode='''r'''	)

						if len(weight_info['''shape''']	) == 0:
												__UpperCamelCase       					=     weight[0]
						__UpperCamelCase       					=     torch.tensor(snake_case	)
						if weight_info["dtype"] == "bfloat16":
												__UpperCamelCase       					=     weight.view(torch.bfloataa	)

						return weight




def 		A_	(							snake_case							:				Dict	, snake_case							:				int	) ->      str:



						'''simple docstring'''

						if index is None or len(snake_case	) == 0:
												# Nothing to save
												return

						__UpperCamelCase       					=     os.path.join(snake_case	, '''index.json'''	)
						if os.path.isfile(snake_case	):
												with open(snake_case	, '''r'''	, encoding='''utf-8'''	) as f:
																		__UpperCamelCase       					=     json.load(snake_case	)
						else:
												__UpperCamelCase       					=     {}
						current_index.update(snake_case	)

						with open(snake_case	, '''w'''	, encoding='''utf-8'''	) as f:
												json.dump(snake_case	, snake_case	, indent=2	)




def 		A_	(							snake_case							:				Union[str, os.PathLike]	, snake_case							:				Dict[str, torch.Tensor]	) ->      Dict:



						'''simple docstring'''

						os.makedirs(snake_case	, exist_ok=snake_case	)
						__UpperCamelCase       					=     {}
						for name, parameter in state_dict.items():
												__UpperCamelCase       					=     offload_weight(snake_case	, snake_case	, snake_case	, index=snake_case	)

						# Update index
						save_offload_index(snake_case	, snake_case	)






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							def __init__(					self       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )->				str:





													'''simple docstring'''






													__UpperCamelCase       					=     dataset
													__UpperCamelCase       					=     prefix



							def __getitem__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Union[str, Any]:





													'''simple docstring'''






													return self.dataset[F"{self.prefix}{key}"]



							def __iter__(					self     )->				Union[str, Any]:





													'''simple docstring'''






													return iter([key for key in self.dataset if key.startswith(self.prefix     )]     )



							def __len__(					self     )->				str:





													'''simple docstring'''






													return len(self.dataset     )






class     SCREAMING_SNAKE_CASE__      (							SCREAMING_SNAKE_CASE_      ):

							"""simple docstring"""






							def __init__(					self       ,		SCREAMING_SNAKE_CASE_ = None       ,		SCREAMING_SNAKE_CASE_ = None       ,		SCREAMING_SNAKE_CASE_ = None       ,		SCREAMING_SNAKE_CASE_=None       ,		)->				Tuple:





													'''simple docstring'''






													if state_dict is None and save_folder is None:
																			raise ValueError('''Need either a `state_dict` or a `save_folder` containing offloaded weights.'''     )

													__UpperCamelCase       					=     {} if state_dict is None else state_dict
													__UpperCamelCase       					=     save_folder
													if index is None and save_folder is not None:
																			with open(os.path.join(SCREAMING_SNAKE_CASE_       ,		'''index.json'''     )     ) as f:
																									__UpperCamelCase       					=     json.load(SCREAMING_SNAKE_CASE_     )
													__UpperCamelCase       					=     {} if index is None else index
													__UpperCamelCase       					=     list(self.state_dict.keys()     )
													self.all_keys.extend([key for key in self.index if key not in self.all_keys]     )
													__UpperCamelCase       					=     device



							def __getitem__(					self       ,		SCREAMING_SNAKE_CASE_     )->				Tuple:





													'''simple docstring'''






													if key in self.state_dict:
																			return self.state_dict[key]
													__UpperCamelCase       					=     self.index[key]
													if weight_info.get('''safetensors_file'''     ) is not None:
																			if not is_safetensors_available():
																									raise ImportError('''These offloaded weights require the use of safetensors: `pip install safetensors`.'''     )

																			from safetensors import safe_open

																			__UpperCamelCase       					=     '''cpu''' if self.device is None else self.device
																			with safe_open(weight_info['''safetensors_file''']       ,		framework='''pt'''       ,		device=SCREAMING_SNAKE_CASE_     ) as f:
																									__UpperCamelCase       					=     f.get_tensor(weight_info.get('''weight_name'''       ,		SCREAMING_SNAKE_CASE_     )     )

																			if "dtype" in weight_info:
																									return tensor.to(getattr(SCREAMING_SNAKE_CASE_       ,		weight_info['''dtype''']     )     )
																			else:
																									return tensor

													__UpperCamelCase       					=     os.path.join(self.save_folder       ,		F"{key}.dat"     )
													return load_offloaded_weight(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_     )



							def __iter__(					self     )->				Dict:





													'''simple docstring'''






													return iter(self.all_keys     )



							def __len__(					self     )->				Dict:





													'''simple docstring'''






													return len(self.all_keys     )





def 		A_	(							snake_case							:				Dict[str, torch.Tensor]	, snake_case							:				List[str]	) ->      Tuple:



						'''simple docstring'''

						__UpperCamelCase       					=     {}
						for module_name in submodule_names:
												# We want to catch module_name parameter (module_name.xxx) or potentially module_name, but not any of the
												# submodules that could being like module_name (transformers.h.1 and transformers.h.10 for instance)
												result.update(
												    {
												        key: param
												        for key, param in state_dict.items()
												        if key == module_name or key.startswith(module_name + '''.'''	)
												    }	)
						return result




