


import torch.nn as nn

from .imports import is_fpa_available


if is_fpa_available():
  import transformer_engine.pytorch as te






def  _UpperCAmelCase						( __lowerCamelCase			,  __lowerCamelCase=True			,  __lowerCamelCase=True			,  __lowerCamelCase=True							)		->Dict:


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

   setattr(__snake_case			,  __snake_case			,  __snake_case							)
  elif isinstance(__snake_case			,  nn.LayerNorm							) and to_transformer_engine and _convert_ln:
   snake_case :			Union[str, Any]							=   te.LayerNorm(module.normalized_shape[0]			,  eps=module.eps			,  params_dtype=module.weight.dtype							)
   snake_case :			Optional[int]							=   module.weight.data.clone()
   snake_case :			Optional[int]							=   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:
   snake_case :			str							=   module.bias is not None
   snake_case :			Optional[int]							=   nn.Linear(
       module.in_features			,  module.out_features			,  bias=__snake_case			,  params_dtype=module.weight.dtype							)
   snake_case :			Union[str, Any]							=   module.weight.data.clone()
   if has_bias:
    snake_case :			Union[str, Any]							=   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:
   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 :			Optional[int]							=   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  _UpperCAmelCase						( __lowerCamelCase							)		->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








from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
 import PIL


lowerCamelCase_				:							List[str]       =    logging.get_logger(__name__)







class  _lowerCamelCase			(lowerCamelCase					):
     lowercase__				  =			["""pixel_values"""]

     def __init__(  self							,       SCREAMING_SNAKE_CASE_ = True							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = PIL.Image.NEAREST							,       SCREAMING_SNAKE_CASE_ = False							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = 1 / 255							,       SCREAMING_SNAKE_CASE_ = False							,       SCREAMING_SNAKE_CASE_ = True							,       SCREAMING_SNAKE_CASE_ = True							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = True							,       **SCREAMING_SNAKE_CASE_							,       ):
            super().__init__(**SCREAMING_SNAKE_CASE_    )
            __snake_case						       =   size if size is not None else {'height': 346, 'width': 346}
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_    )
            __snake_case						       =   crop_size if crop_size is not None else {'height': 289, 'width': 289}
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_							,       param_name='crop_size'    )

            __snake_case						       =   do_resize
            __snake_case						       =   size
            __snake_case						       =   resample
            __snake_case						       =   do_center_crop
            __snake_case						       =   crop_size
            __snake_case						       =   do_rescale
            __snake_case						       =   rescale_factor
            __snake_case						       =   rescale_offset
            __snake_case						       =   do_normalize
            __snake_case						       =   image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
            __snake_case						       =   image_std if image_std is not None else IMAGENET_STANDARD_STD
            __snake_case						       =   include_top

     def 						__lowerCamelCase				(  self							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = PIL.Image.NEAREST							,       SCREAMING_SNAKE_CASE_ = None							,       **SCREAMING_SNAKE_CASE_							,       ):
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_    )
            if "height" not in size or "width" not in size:
                   raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''    )
            return resize(
                SCREAMING_SNAKE_CASE_							,       size=(size['height'], size['width'])							,       resample=SCREAMING_SNAKE_CASE_							,       data_format=SCREAMING_SNAKE_CASE_							,       **SCREAMING_SNAKE_CASE_    )

     def 						__lowerCamelCase				(  self							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = None							,       **SCREAMING_SNAKE_CASE_							,       ):
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_    )
            if "height" not in size or "width" not in size:
                   raise ValueError(f'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''    )
            return center_crop(SCREAMING_SNAKE_CASE_							,       size=(size['height'], size['width'])							,       data_format=SCREAMING_SNAKE_CASE_							,       **SCREAMING_SNAKE_CASE_    )

     def 						__lowerCamelCase				(  self							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = True							,       SCREAMING_SNAKE_CASE_ = None							,       **SCREAMING_SNAKE_CASE_							,       ):
            if offset:
                   __snake_case						       =   (image - 1_2_7.5) * scale
                   if data_format is not None:
                          __snake_case						       =   to_channel_dimension_format(SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_    )
                   __snake_case						       =   rescaled_image.astype(np.floataa    )
            else:
                   __snake_case						       =   rescale(SCREAMING_SNAKE_CASE_							,       scale=SCREAMING_SNAKE_CASE_							,       data_format=SCREAMING_SNAKE_CASE_							,       **SCREAMING_SNAKE_CASE_    )
            return rescaled_image

     def 						__lowerCamelCase				(  self							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = None							,       **SCREAMING_SNAKE_CASE_							,       ):
            return normalize(SCREAMING_SNAKE_CASE_							,       mean=SCREAMING_SNAKE_CASE_							,       std=SCREAMING_SNAKE_CASE_							,       data_format=SCREAMING_SNAKE_CASE_							,       **SCREAMING_SNAKE_CASE_    )

     def 						__lowerCamelCase				(  self							,       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_=None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = ChannelDimension.FIRST							,       **SCREAMING_SNAKE_CASE_							,       ):
            __snake_case						       =   do_resize if do_resize is not None else self.do_resize
            __snake_case						       =   resample if resample is not None else self.resample
            __snake_case						       =   do_center_crop if do_center_crop is not None else self.do_center_crop
            __snake_case						       =   do_rescale if do_rescale is not None else self.do_rescale
            __snake_case						       =   rescale_factor if rescale_factor is not None else self.rescale_factor
            __snake_case						       =   rescale_offset if rescale_offset is not None else self.rescale_offset
            __snake_case						       =   do_normalize if do_normalize is not None else self.do_normalize
            __snake_case						       =   image_mean if image_mean is not None else self.image_mean
            __snake_case						       =   image_std if image_std is not None else self.image_std
            __snake_case						       =   include_top if include_top is not None else self.include_top

            __snake_case						       =   size if size is not None else self.size
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_    )
            __snake_case						       =   crop_size if crop_size is not None else self.crop_size
            __snake_case						       =   get_size_dict(SCREAMING_SNAKE_CASE_							,       param_name='crop_size'    )

            __snake_case						       =   make_list_of_images(SCREAMING_SNAKE_CASE_    )

            if not valid_images(SCREAMING_SNAKE_CASE_    ):
                   raise ValueError(
                       'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                       'torch.Tensor, tf.Tensor or jax.ndarray.'    )

            if do_resize and size is None or resample is None:
                   raise ValueError('Size and resample must be specified if do_resize is True.'    )

            if do_center_crop and crop_size is None:
                   raise ValueError('Crop size must be specified if do_center_crop is True.'    )

            if do_rescale and rescale_factor is None:
                   raise ValueError('Rescale factor must be specified if do_rescale is True.'    )

            if do_normalize and (image_mean is None or image_std is None):
                   raise ValueError('Image mean and std must be specified if do_normalize is True.'    )

            # All transformations expect numpy arrays.
            __snake_case						       =   [to_numpy_array(SCREAMING_SNAKE_CASE_    ) for image in images]

            if do_resize:
                   __snake_case						       =   [self.resize(image=SCREAMING_SNAKE_CASE_							,       size=SCREAMING_SNAKE_CASE_							,       resample=SCREAMING_SNAKE_CASE_    ) for image in images]

            if do_center_crop:
                   __snake_case						       =   [self.center_crop(image=SCREAMING_SNAKE_CASE_							,       size=SCREAMING_SNAKE_CASE_    ) for image in images]

            if do_rescale:
                   __snake_case						       =   [self.rescale(image=SCREAMING_SNAKE_CASE_							,       scale=SCREAMING_SNAKE_CASE_							,       offset=SCREAMING_SNAKE_CASE_    ) for image in images]

            if do_normalize:
                   __snake_case						       =   [self.normalize(image=SCREAMING_SNAKE_CASE_							,       mean=SCREAMING_SNAKE_CASE_							,       std=SCREAMING_SNAKE_CASE_    ) for image in images]

            if include_top:
                   __snake_case						       =   [self.normalize(image=SCREAMING_SNAKE_CASE_							,       mean=[0, 0, 0]							,       std=SCREAMING_SNAKE_CASE_    ) for image in images]

            __snake_case						       =   [to_channel_dimension_format(SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_    ) for image in images]

            __snake_case						       =   {'pixel_values': images}
            return BatchFeature(data=SCREAMING_SNAKE_CASE_							,       tensor_type=SCREAMING_SNAKE_CASE_    )
