






from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available




def   lowercase__   (  __snake_case					:							Union[str, Any]						):


					'''simple docstring'''


					if is_torch_available():
										import torch

										if isinstance(__snake_case  , torch.Tensor						):
															return True

					return isinstance(__snake_case  , np.ndarray						)






class 						lowerCamelCase   (_snake_case    ):







		'''simple docstring'''



		def       __UpperCAmelCase    (							self     )			->							Any:
							UpperCAmelCase_					:   str   =		fields(self     )

							# Safety and consistency checks
							if not len(_UpperCamelCase     ):
												raise ValueError(f"{self.__class__.__name__} has no fields."     )

							UpperCAmelCase_					:   Any   =		getattr(self       ,	class_fields[0].name     )
							UpperCAmelCase_					:   Tuple   =		all(getattr(self       ,	field.name     ) is None for field in class_fields[1:]     )

							if other_fields_are_none and isinstance(_UpperCamelCase       ,	_UpperCamelCase     ):
												for key, value in first_field.items():
																	UpperCAmelCase_					:   int   =		value
							else:
												for field in class_fields:
																	UpperCAmelCase_					:   int   =		getattr(self       ,	field.name     )
																	if v is not None:
																						UpperCAmelCase_					:   Dict   =		v



		def __delitem__(							self       ,	*_UpperCamelCase       ,	**_UpperCamelCase     )			->							Optional[int]:
							raise Exception(f"You cannot use ``__delitem__`` on a {self.__class__.__name__} instance."     )



		def       __UpperCAmelCase    (							self       ,	*_UpperCamelCase       ,	**_UpperCamelCase     )			->							Optional[int]:
							raise Exception(f"You cannot use ``setdefault`` on a {self.__class__.__name__} instance."     )



		def       __UpperCAmelCase    (							self       ,	*_UpperCamelCase       ,	**_UpperCamelCase     )			->							List[Any]:
							raise Exception(f"You cannot use ``pop`` on a {self.__class__.__name__} instance."     )



		def       __UpperCAmelCase    (							self       ,	*_UpperCamelCase       ,	**_UpperCamelCase     )			->							Optional[int]:
							raise Exception(f"You cannot use ``update`` on a {self.__class__.__name__} instance."     )



		def __getitem__(							self       ,	_UpperCamelCase     )			->							Union[str, Any]:
							if isinstance(_UpperCamelCase       ,	_UpperCamelCase     ):
												UpperCAmelCase_					:   int   =		dict(self.items()     )
												return inner_dict[k]
							else:
												return self.to_tuple()[k]



		def __setattr__(							self       ,	_UpperCamelCase       ,	_UpperCamelCase     )			->							Tuple:
							if name in self.keys() and value is not None:
												# Don't call self.__setitem__ to avoid recursion errors
												super().__setitem__(_UpperCamelCase       ,	_UpperCamelCase     )
							super().__setattr__(_UpperCamelCase       ,	_UpperCamelCase     )



		def __setitem__(							self       ,	_UpperCamelCase       ,	_UpperCamelCase     )			->							Union[str, Any]:
							# Will raise a KeyException if needed
							super().__setitem__(_UpperCamelCase       ,	_UpperCamelCase     )
							# Don't call self.__setattr__ to avoid recursion errors
							super().__setattr__(_UpperCamelCase       ,	_UpperCamelCase     )



		def       __UpperCAmelCase    (							self     )			->							Tuple[Any]:
							return tuple(self[k] for k in self.keys()     )














import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
		import transformer_engine.pytorch as te




def   lowercase__   (  __snake_case					:							List[str]  , __snake_case					:							List[Any]=True  , __snake_case					:							str=True  , __snake_case					:							Tuple=True						):


					'''simple docstring'''


					if not is_fpa_available():
										raise ImportError('Using `convert_model` requires transformer_engine to be installed.'						)
					for name, module in model.named_children():
										if isinstance(__snake_case  , nn.Linear						) and to_transformer_engine and _convert_linear:
															# Return early if the linear layer weights are not multiples of 16
															if any(p % 16 != 0 for p in module.weight.shape						):
																				return
															UpperCAmelCase_					:   Optional[int]   =		module.bias is not None
															UpperCAmelCase_					:   Optional[int]   =		te.Linear(
															    module.in_features  , module.out_features  , bias=__snake_case  , params_dtype=module.weight.dtype						)
															UpperCAmelCase_					:   List[str]   =		module.weight.data.clone()
															if has_bias:
																				UpperCAmelCase_					:   List[Any]   =		module.bias.data.clone()

															setattr(__snake_case  , __snake_case  , __snake_case						)
										elif isinstance(__snake_case  , nn.LayerNorm						) and to_transformer_engine and _convert_ln:
															UpperCAmelCase_					:   int   =		te.LayerNorm(module.normalized_shape[0]  , eps=module.eps  , params_dtype=module.weight.dtype						)
															UpperCAmelCase_					:   Any   =		module.weight.data.clone()
															UpperCAmelCase_					:   Any   =		module.bias.data.clone()

															setattr(__snake_case  , __snake_case  , __snake_case						)
										elif isinstance(__snake_case  , te.Linear						) and not to_transformer_engine and _convert_linear:
															UpperCAmelCase_					:   int   =		module.bias is not None
															UpperCAmelCase_					:   Tuple   =		nn.Linear(
															    module.in_features  , module.out_features  , bias=__snake_case  , params_dtype=module.weight.dtype						)
															UpperCAmelCase_					:   str   =		module.weight.data.clone()
															if has_bias:
																				UpperCAmelCase_					:   Dict   =		module.bias.data.clone()

															setattr(__snake_case  , __snake_case  , __snake_case						)
										elif isinstance(__snake_case  , te.LayerNorm						) and not to_transformer_engine and _convert_ln:
															UpperCAmelCase_					:   List[Any]   =		nn.LayerNorm(module.normalized_shape[0]  , eps=module.eps  , params_dtype=module.weight.dtype						)
															UpperCAmelCase_					:   List[str]   =		module.weight.data.clone()
															UpperCAmelCase_					:   Tuple   =		module.bias.data.clone()

															setattr(__snake_case  , __snake_case  , __snake_case						)
										else:
															convert_model(
															    __snake_case  , to_transformer_engine=__snake_case  , _convert_linear=_convert_linear  , _convert_ln=_convert_ln  , )






def   lowercase__   (  __snake_case					:							List[Any]						):


					'''simple docstring'''


					if not is_fpa_available():
										raise ImportError('Using `has_transformer_engine_layers` requires transformer_engine to be installed.'						)
					for m in model.modules():
										if isinstance(__snake_case  , (te.LayerNorm, te.Linear)						):
															return True
					return False






