

import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
       import transformer_engine.pytorch as te





def 			_lowercase    (      __UpperCamelCase     :		int   ,       __UpperCamelCase     :		Any=True   ,       __UpperCamelCase     :		Dict=True   ,       __UpperCamelCase     :		Optional[Any]=True ):
      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(__UpperCamelCase   ,       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__					=   module.bias is not None
                  snake_case__					=   te.Linear(
                      module.in_features   ,       module.out_features   ,       bias=__UpperCamelCase   ,       params_dtype=module.weight.dtype )
                  snake_case__					=   module.weight.data.clone()
                  if has_bias:
                        snake_case__					=   module.bias.data.clone()

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

                  setattr(__UpperCamelCase   ,       __UpperCamelCase   ,       __UpperCamelCase )
            elif isinstance(__UpperCamelCase   ,       te.Linear ) and not to_transformer_engine and _convert_linear:
                  snake_case__					=   module.bias is not None
                  snake_case__					=   nn.Linear(
                      module.in_features   ,       module.out_features   ,       bias=__UpperCamelCase   ,       params_dtype=module.weight.dtype )
                  snake_case__					=   module.weight.data.clone()
                  if has_bias:
                        snake_case__					=   module.bias.data.clone()

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

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





def 			_lowercase    (      __UpperCamelCase     :		str ):
      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(__UpperCamelCase   ,       (te.LayerNorm, te.Linear) ):
                  return True
      return False









import sys





def 			_lowercase    (      __UpperCamelCase     :		int   ,       __UpperCamelCase     :		list[int] ):
      if not numbers:
            return 0
      if target == 0 and target in numbers:
            return 0
      if not isinstance(__UpperCamelCase   ,       (list, tuple) ) or not all(
          isinstance(__UpperCamelCase   ,       __UpperCamelCase ) for number in numbers ):
            raise ValueError("""numbers must be an iterable of integers""" )

      snake_case__					=   snake_case__					=   snake_case__					=   0
      snake_case__					=   sys.maxsize

      while right < len(__UpperCamelCase ):
            curr_sum += numbers[right]
            while curr_sum >= target and left <= right:
                  snake_case__					=   min(__UpperCamelCase   ,       right - left + 1 )
                  curr_sum -= numbers[left]
                  left += 1
            right += 1

      return 0 if min_len == sys.maxsize else min_len






