



import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
      import transformer_engine.pytorch as te







def       lowerCamelCase_  (    _a       :						Union[str, Any]   ,		_a       :						int=True   ,		_a       :						Dict=True   ,		_a       :						int=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(_a   ,		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_     :       Dict  		=					module.bias is not None
            UpperCAmelCase_     :       Optional[int]  		=					te.Linear(
                module.in_features   ,		module.out_features   ,		bias=_a   ,		params_dtype=module.weight.dtype    )
            UpperCAmelCase_     :       Tuple  		=					module.weight.data.clone()
            if has_bias:
                UpperCAmelCase_     :       Optional[Any]  		=					module.bias.data.clone()

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

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

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

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







def       lowerCamelCase_  (    _a       :						Tuple    ):



    '''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(_a   ,		(te.LayerNorm, te.Linear)    ):
            return True
    return False






"""simple docstring"""



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE							=			{
    "configuration_dpr": ["DPR_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPRConfig"],
    "tokenization_dpr": [
        "DPRContextEncoderTokenizer",
        "DPRQuestionEncoderTokenizer",
        "DPRReaderOutput",
        "DPRReaderTokenizer",
    ],
}


try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "DPRContextEncoderTokenizerFast",
          "DPRQuestionEncoderTokenizerFast",
          "DPRReaderTokenizerFast",
      ]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "DPRContextEncoder",
          "DPRPretrainedContextEncoder",
          "DPRPreTrainedModel",
          "DPRPretrainedQuestionEncoder",
          "DPRPretrainedReader",
          "DPRQuestionEncoder",
          "DPRReader",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      SCREAMING_SNAKE_CASE							=			[
          "TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFDPRContextEncoder",
          "TFDPRPretrainedContextEncoder",
          "TFDPRPretrainedQuestionEncoder",
          "TFDPRPretrainedReader",
          "TFDPRQuestionEncoder",
          "TFDPRReader",
      ]


if TYPE_CHECKING:
      from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
      from .tokenization_dpr import (
          DPRContextEncoderTokenizer,
          DPRQuestionEncoderTokenizer,
          DPRReaderOutput,
          DPRReaderTokenizer,
      )

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_dpr_fast import (
                DPRContextEncoderTokenizerFast,
                DPRQuestionEncoderTokenizerFast,
                DPRReaderTokenizerFast,
            )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_dpr import (
                DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
                DPRContextEncoder,
                DPRPretrainedContextEncoder,
                DPRPreTrainedModel,
                DPRPretrainedQuestionEncoder,
                DPRPretrainedReader,
                DPRQuestionEncoder,
                DPRReader,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_dpr import (
                TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFDPRContextEncoder,
                TFDPRPretrainedContextEncoder,
                TFDPRPretrainedQuestionEncoder,
                TFDPRPretrainedReader,
                TFDPRQuestionEncoder,
                TFDPRReader,
            )

else:
      import sys

      SCREAMING_SNAKE_CASE							=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)





