






'''simple docstring'''

import os
from pathlib import Path
from typing import Dict, List

import fire
import torch

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.utils.logging import get_logger


A:   List[Any]						=					get_logger(__name__)






def 						_UpperCAmelCase     (	a		:						str    ,      a		:						str				)      ->      Any:





						"""simple docstring"""
						if text.startswith(a				):
												return text[len(a				) :]
						return text  # or whatever






def 						_UpperCAmelCase     (	a		:						int				)      ->      Optional[Any]:





						"""simple docstring"""
						return {remove_prefix(a    ,      'model.'				): v for k, v in sd.items()}






def 						_UpperCAmelCase     (	a		:						List[Dict[str, torch.Tensor]]				)      ->      int:





						"""simple docstring"""
						lowercase_   : List[str]   	=      {}
						for k in state_dicts[0].keys():
												lowercase_   : Optional[int]   	=      [sd[k] for sd in state_dicts]
												lowercase_   : List[Any]   	=      sum(a				) / len(a				)
												assert isinstance(a    ,      torch.Tensor				)
												lowercase_   : List[str]   	=      new_t
						return new_sd






def 						_UpperCAmelCase     (	a		:						str    ,      a		:						str    ,      a		:						str				)      ->      None:





						"""simple docstring"""
						lowercase_   : List[Any]   	=      AutoModelForSeqaSeqLM.from_pretrained(a				)
						if os.path.isfile(a				):
												lowercase_   : Optional[Any]   	=      [pl_ckpt_path]
						else:
												assert os.path.isdir(a				)
												lowercase_   : Tuple   	=      list(Path(a				).glob('*.ckpt'				)				)
												assert ckpt_files, f"could not find any ckpt files inside the {pl_ckpt_path} directory"

						if len(a				) > 1:
												logger.info(f"averaging the weights of {ckpt_files}"				)

						lowercase_   : str   	=      [sanitize(torch.load(a    ,      map_location='cpu'				)['state_dict']				) for x in ckpt_files]
						lowercase_   : int   	=      average_state_dicts(a				)

						lowercase_	,   lowercase_   : Union[str, Any]   	=      hf_model.load_state_dict(a    ,      strict=a				)
						assert not missing, f"missing keys: {missing}"
						hf_model.save_pretrained(a				)
						try:
												lowercase_   : Tuple   	=      AutoTokenizer.from_pretrained(a				)
												tok.save_pretrained(a				)
						except Exception:
												pass
												# dont copy tokenizer if cant


if __name__ == "__main__":
						fire.Fire(convert_pl_to_hf)








'''simple docstring'''

import inspect
import warnings

import torch

from .state import AcceleratorState, GradientState
from .utils import DistributedType, honor_type, is_tpu_available


if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm






def 						_UpperCAmelCase     (	a		:						Tuple    ,      a		:						int				)      ->      List[str]:





						"""simple docstring"""
						if isinstance(a    ,      (list, tuple)				):
												return honor_type(a    ,      (move_to_device(a    ,      a				) for t in state)				)
						elif isinstance(a    ,      a				):
												return type(a				)({k: move_to_device(a    ,      a				) for k, v in state.items()}				)
						elif isinstance(a    ,      torch.Tensor				):
												return state.to(a				)
						return state






class 				__magic_name__  (						torch.optim.Optimizer					):







	"""simple docstring"""



	def __init__(				self	,   _lowercase	,   _lowercase=True	,   _lowercase=None							)    ->	int:
							lowercase_   : List[str]   	=      optimizer
							lowercase_   : Optional[int]   	=      scaler
							lowercase_   : Union[str, Any]   	=      AcceleratorState()
							lowercase_   : Optional[Any]   	=      GradientState()
							lowercase_   : Union[str, Any]   	=      device_placement
							lowercase_   : List[str]   	=      False
							lowercase_   : Optional[Any]   	=      None

							# Handle device placement
							if device_placement:
													lowercase_   : str   	=      self.optimizer.state_dict()
													if self.accelerator_state.distributed_type == DistributedType.TPU:
																			xm.send_cpu_data_to_device(_lowercase	,   self.accelerator_state.device							)
													else:
																			lowercase_   : List[str]   	=      move_to_device(_lowercase	,   self.accelerator_state.device							)
													self.optimizer.load_state_dict(_lowercase							)
	@property
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.state
	@state.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Union[str, Any]:
							lowercase_   : Optional[Any]   	=      state
	@property
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.param_groups
	@param_groups.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Optional[Any]:
							lowercase_   : Dict   	=      param_groups
	@property
	def 							lowerCamelCase__		(				self							)    ->	int:
							return self.optimizer.defaults
	@defaults.setter
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Any:
							lowercase_   : List[Any]   	=      defaults
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Tuple:
							self.optimizer.add_param_group(_lowercase							)
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Any:
							if self.accelerator_state.distributed_type == DistributedType.TPU and self.device_placement:
													xm.send_cpu_data_to_device(_lowercase	,   self.accelerator_state.device							)
							self.optimizer.load_state_dict(_lowercase							)
	def 							lowerCamelCase__		(				self							)    ->	Any:
							return self.optimizer.state_dict()
	def 							lowerCamelCase__		(				self	,   _lowercase=None							)    ->	Optional[Any]:
							if self.gradient_state.sync_gradients:
													lowercase_   : Tuple   	=      'set_to_none' in inspect.signature(self.optimizer.zero_grad							).parameters
													if accept_arg:
																			if set_to_none is None:
																									lowercase_   : Optional[int]   	=      False
																			self.optimizer.zero_grad(set_to_none=_lowercase							)
													else:
																			if set_to_none is not None:
																									raise ValueError('`set_to_none` for Optimizer.zero_grad` is not supported by this optimizer.'							)
																			self.optimizer.zero_grad()
	def 							lowerCamelCase__		(				self	,   _lowercase=None							)    ->	Optional[Any]:
							if self.gradient_state.sync_gradients:
													if self.accelerator_state.distributed_type == DistributedType.TPU:
																			lowercase_   : Union[str, Any]   	=      {'closure': closure} if closure is not None else {}
																			xm.optimizer_step(self.optimizer	,   optimizer_args=_lowercase							)
													elif self.scaler is not None:
																			lowercase_   : Optional[Any]   	=      False
																			if self._last_scale is None:
																									# `get_scale` is an async operation requiring full synchronization
																									# on CPU and GPUs before finishing. As a result, we store away
																									# the prior one to reduce the call overhead
																									lowercase_   : Tuple   	=      self.scaler.get_scale()
																									lowercase_   : int   	=      True
																			self.scaler.step(self.optimizer	,   _lowercase							)
																			self.scaler.update()
																			lowercase_   : List[str]   	=      self.scaler.get_scale()
																			if not new_scale:
																									# If we reduced the loss scale, it means the optimizer step was skipped because of gradient overflow.
																									lowercase_   : Optional[int]   	=      scale_after < self._last_scale
																			lowercase_   : List[str]   	=      scale_after

													else:
																			self.optimizer.step(_lowercase							)
	def 							lowerCamelCase__		(				self	,   _lowercase							)    ->	Optional[int]:
							for param_group in self.optimizer.param_groups:
													lowercase_   : Dict   	=      [parameters_map.get(_lowercase	,   _lowercase							) for p in param_group['params']]
	@property
	def 							lowerCamelCase__		(				self							)    ->	List[Any]:
							warnings.warn(
							    'The `is_overflow` property is deprecated and will be removed in version 1.0 of Accelerate use '
							    '`optimizer.step_was_skipped` instead.'	,   _lowercase	,   )
							return self._is_overflow
	@property
	def 							lowerCamelCase__		(				self							)    ->	str:
							return self._is_overflow
	def __getstate__(				self							)    ->	str:
							return self.__dict__.copy()







	def __setstate__(				self	,   _lowercase							)    ->	Union[str, Any]:
							self.__dict__.update(_lowercase							)
