
'''simple docstring'''
import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
						import transformer_engine.pytorch as te




def 					_UpperCamelCase		(    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__=True      ,    SCREAMING_SNAKE_CASE__=True      ,    SCREAMING_SNAKE_CASE__=True       )   ->				Optional[int]:


		'''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(SCREAMING_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
						snake_case   :    List[str]			       =		module.bias is not None
						snake_case   :    Union[str, Any]			       =		te.Linear(
						    module.in_features      ,    module.out_features      ,    bias=SCREAMING_SNAKE_CASE__      ,    params_dtype=module.weight.dtype       )
						snake_case   :    Union[str, Any]			       =		module.weight.data.clone()
						if has_bias:
								snake_case   :    Tuple			       =		module.bias.data.clone()

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

						setattr(SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__      ,    SCREAMING_SNAKE_CASE__       )
				elif isinstance(SCREAMING_SNAKE_CASE__      ,    te.Linear       ) and not to_transformer_engine and _convert_linear:
						snake_case   :    Optional[Any]			       =		module.bias is not None
						snake_case   :    Optional[Any]			       =		nn.Linear(
						    module.in_features      ,    module.out_features      ,    bias=SCREAMING_SNAKE_CASE__      ,    params_dtype=module.weight.dtype       )
						snake_case   :    Optional[int]			       =		module.weight.data.clone()
						if has_bias:
								snake_case   :    Dict			       =		module.bias.data.clone()

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

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




def 					_UpperCamelCase		(    SCREAMING_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(SCREAMING_SNAKE_CASE__      ,    (te.LayerNorm, te.Linear)       ):
						return True
		return False




"""simple docstring"""




from __future__ import annotations

def   UpperCamelCase_  (		SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_,     SCREAMING_SNAKE_CASE_			):
					SCREAMING_SNAKE_CASE	,    SCREAMING_SNAKE_CASE				=	m - 1, 0
					while i >= 0 and j < n:
										if key == mat[i][j]:
															print(f'''Key {key} found at row- {i + 1} column- {j + 1}'''			)
															return
										if key < mat[i][j]:
															i -= 1
										else:
															j += 1
					print(f'''Key {key} not found'''			)

def   UpperCamelCase_  (		):
					SCREAMING_SNAKE_CASE				=	[[2, 5, 7], [4, 8, 1_3], [9, 1_1, 1_5], [1_2, 1_7, 2_0]]
					SCREAMING_SNAKE_CASE				=	int(input('Enter the element to be searched:'			)			)
					print(SCREAMING_SNAKE_CASE_			)
					search_in_a_sorted_matrix(SCREAMING_SNAKE_CASE_,     len(SCREAMING_SNAKE_CASE_			),     len(mat[0]			),     SCREAMING_SNAKE_CASE_			)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()
