





'''simple docstring'''





import importlib.metadata
import warnings
from copy import deepcopy

from packaging import version

from ..utils import logging
from .import_utils import is_accelerate_available, is_bitsandbytes_available


if is_bitsandbytes_available():
     import bitsandbytes as bnb
     import torch
     import torch.nn as nn

     from ..pytorch_utils import ConvaD

if is_accelerate_available():
     from accelerate import init_empty_weights
     from accelerate.utils import find_tied_parameters

__A             =       logging.get_logger(__name__)





def   lowerCAmelCase_				( __a			,					__a			,					__a			,					__a=None			,					__a=None	)  ->	Optional[int]:







  """simple docstring"""





  if "." in tensor_name:
    lowerCamelCase__:   Any    						=tensor_name.split("."	)
    for split in splits[:-1]:
      lowerCamelCase__:   Tuple    						=getattr(__a			,					__a	)
      if new_module is None:
        raise ValueError(F"""{module} has no attribute {split}."""	)
      lowerCamelCase__:   Any    						=new_module
    lowerCamelCase__:   List[str]    						=splits[-1]

  if tensor_name not in module._parameters and tensor_name not in module._buffers:
    raise ValueError(F"""{module} does not have a parameter or a buffer named {tensor_name}."""	)
  lowerCamelCase__:   Any    						=tensor_name in module._buffers
  lowerCamelCase__:   Dict    						=getattr(__a			,					__a	)

  if old_value.device == torch.device("meta"	) and device not in ["meta", torch.device("meta"	)] and value is None:
    raise ValueError(F"""{tensor_name} is on the meta device, we need a `value` to put in on {device}."""	)

  lowerCamelCase__:   str    						=False
  lowerCamelCase__:   Dict    						=False
  if is_buffer or not is_bitsandbytes_available():
    lowerCamelCase__:   int    						=False
    lowerCamelCase__:   List[str]    						=False
  else:
    lowerCamelCase__:   Optional[int]    						=hasattr(bnb.nn			,					"Params4bit"	) and isinstance(module._parameters[tensor_name]			,					bnb.nn.Paramsabit	)
    lowerCamelCase__:   List[str]    						=isinstance(module._parameters[tensor_name]			,					bnb.nn.IntaParams	)

  if is_abit or is_abit:
    lowerCamelCase__:   Optional[Any]    						=module._parameters[tensor_name]
    if param.device.type != "cuda":
      if value is None:
        lowerCamelCase__:   Optional[Any]    						=old_value.to(__a	)
      elif isinstance(__a			,					torch.Tensor	):
        lowerCamelCase__:   Optional[int]    						=value.to("cpu"	)
        if value.dtype == torch.inta:
          lowerCamelCase__:   Optional[Any]    						=version.parse(importlib.metadata.version("bitsandbytes"	)	) > version.parse(
              "0.37.2"	)
          if not is_abit_serializable:
            raise ValueError(
                "Detected int8 weights but the version of bitsandbytes is not compatible with int8 serialization. "
                "Make sure to download the latest `bitsandbytes` version. `pip install --upgrade bitsandbytes`."	)
      else:
        lowerCamelCase__:   Any    						=torch.tensor(__a			,					device="cpu"	)

      # Support models using `Conv1D` in place of `nn.Linear` (e.g. gpt2) by transposing the weight matrix prior to quantization.
      # Since weights are saved in the correct "orientation", we skip transposing when loading.
      if issubclass(module.source_cls			,					__a	) and fpaa_statistics is None:
        lowerCamelCase__:   int    						=new_value.T

      lowerCamelCase__:   Tuple    						=old_value.__dict__
      if is_abit:
        lowerCamelCase__:   Dict    						=bnb.nn.IntaParams(__a			,					requires_grad=__a			,					**__a	).to(__a	)
      elif is_abit:
        lowerCamelCase__:   Optional[Any]    						=bnb.nn.Paramsabit(__a			,					requires_grad=__a			,					**__a	).to(__a	)

      lowerCamelCase__:   Optional[int]    						=new_value
      if fpaa_statistics is not None:
        setattr(module.weight			,					"SCB"			,					fpaa_statistics.to(__a	)	)

  else:
    if value is None:
      lowerCamelCase__:   str    						=old_value.to(__a	)
    elif isinstance(__a			,					torch.Tensor	):
      lowerCamelCase__:   List[str]    						=value.to(__a	)
    else:
      lowerCamelCase__:   Tuple    						=torch.tensor(__a			,					device=__a	)

    if is_buffer:
      lowerCamelCase__:   List[str]    						=new_value
    else:
      lowerCamelCase__:   str    						=nn.Parameter(__a			,					requires_grad=old_value.requires_grad	)
      lowerCamelCase__:   Optional[int]    						=new_value





def   lowerCAmelCase_				( __a			,					__a=None			,					__a=None			,					__a=None			,					__a=False	)  ->	Union[str, Any]:







  """simple docstring"""





  for name, module in model.named_children():
    if current_key_name is None:
      lowerCamelCase__:   Union[str, Any]    						=[]
    current_key_name.append(__a	)

    if (isinstance(__a			,					nn.Linear	) or isinstance(__a			,					__a	)) and name not in modules_to_not_convert:
      # Check if the current key is not in the `modules_to_not_convert`
      if not any(key in ".".join(__a	) for key in modules_to_not_convert	):
        with init_empty_weights():
          if isinstance(__a			,					__a	):
            lowerCamelCase__:   Optional[Any]    						=module.weight.shape
          else:
            lowerCamelCase__:   Any    						=module.in_features
            lowerCamelCase__:   List[Any]    						=module.out_features

          if quantization_config.quantization_method() == "llm_int8":
            lowerCamelCase__:   List[Any]    						=bnb.nn.LinearabitLt(
                __a			,					__a			,					module.bias is not None			,					has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight			,					threshold=quantization_config.llm_inta_threshold			,					)
            lowerCamelCase__:   List[Any]    						=True
          else:
            if (
                quantization_config.llm_inta_skip_modules is not None
                and name in quantization_config.llm_inta_skip_modules
            ):
              pass
            else:
              lowerCamelCase__:   str    						=bnb.nn.Linearabit(
                  __a			,					__a			,					module.bias is not None			,					quantization_config.bnb_abit_compute_dtype			,					compress_statistics=quantization_config.bnb_abit_use_double_quant			,					quant_type=quantization_config.bnb_abit_quant_type			,					)
              lowerCamelCase__:   Optional[int]    						=True
                    # Store the module class in case we need to transpose the weight later
          lowerCamelCase__:   Optional[int]    						=type(__a	)
          # Force requires grad to False to avoid unexpected errors
          model._modules[name].requires_grad_(__a	)
    if len(list(module.children()	)	) > 0:
      lowerCamelCase__:   List[str]    						=_replace_with_bnb_linear(
          __a			,					__a			,					__a			,					__a			,					has_been_replaced=__a			,					)
    # Remove the last key for recursion
    current_key_name.pop(-1	)
  return model, has_been_replaced





def   lowerCAmelCase_				( __a			,					__a=None			,					__a=None			,					__a=None	)  ->	Any:







  """simple docstring"""





  lowerCamelCase__:   int    						=["lm_head"] if modules_to_not_convert is None else modules_to_not_convert
  lowerCamelCase__:   Optional[int]    						=_replace_with_bnb_linear(
      __a			,					__a			,					__a			,					__a	)

  if not has_been_replaced:
    logger.warning(
        "You are loading your model in 8bit or 4bit but no linear modules were found in your model."
        " Please double check your model architecture, or submit an issue on github if you think this is"
        " a bug."	)

  return model





def   lowerCAmelCase_				( *__a			,					**__a	)  ->	Optional[int]:







  """simple docstring"""





  warnings.warn(
      "`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead"			,					__a			,					)
  return replace_with_bnb_linear(*__a			,					**__a	)





def   lowerCAmelCase_				( *__a			,					**__a	)  ->	int:







  """simple docstring"""





  warnings.warn(
      "`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead"			,					__a			,					)
  return set_module_quantized_tensor_to_device(*__a			,					**__a	)






def   lowerCAmelCase_				( __a	)  ->	Any:







  """simple docstring"""





  lowerCamelCase__:   List[Any]    						=deepcopy(__a	)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
  tied_model.tie_weights()

  lowerCamelCase__:   Optional[Any]    						=find_tied_parameters(__a	)
  # For compatibility with Accelerate < 0.18
  if isinstance(__a			,					__a	):
    lowerCamelCase__:   Dict    						=sum(list(tied_params.values()	)			,					[]	) + list(tied_params.keys()	)
  else:
    lowerCamelCase__:   List[Any]    						=sum(__a			,					[]	)
  lowerCamelCase__:   List[Any]    						=len(__a	) > 0

  # Check if it is a base model
  lowerCamelCase__:   Union[str, Any]    						=not hasattr(__a			,					model.base_model_prefix	)

  # Ignore this for base models (BertModel, GPT2Model, etc.)
  if (not has_tied_params) and is_base_model:
    return []

  # otherwise they have an attached head
  lowerCamelCase__:   Tuple    						=list(model.named_children()	)
  lowerCamelCase__:   int    						=[list_modules[-1][0]]

  # add last module together with tied weights
  lowerCamelCase__:   List[Any]    						=set(__a	) - set(__a	)
  lowerCamelCase__:   Tuple    						=list(set(__a	)	) + list(__a	)

  # remove ".weight" from the keys
  lowerCamelCase__:   List[str]    						=[".weight", ".bias"]
  lowerCamelCase__:   Optional[int]    						=[]
  for name in list_untouched:
    for name_to_remove in names_to_remove:
      if name_to_remove in name:
        lowerCamelCase__:   int    						=name.replace(__a			,					""	)
    filtered_module_names.append(__a	)

  return filtered_module_names








from typing import Dict, List, Optional, Union

import numpy as np

from transformers.utils import is_vision_available
from transformers.utils.generic import TensorType

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


if is_vision_available():
     import PIL

__A             =       logging.get_logger(__name__)





def   lowerCAmelCase_				( __a	)  ->	List[List[ImageInput]]:







  """simple docstring"""





  if isinstance(__a			,					(list, tuple)	) and isinstance(videos[0]			,					(list, tuple)	) and is_valid_image(videos[0][0]	):
    return videos

  elif isinstance(__a			,					(list, tuple)	) and is_valid_image(videos[0]	):
    return [videos]

  elif is_valid_image(__a	):
    return [[videos]]

  raise ValueError(F"""Could not make batched video from {videos}"""	)






class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					):







 '''simple docstring'''
 lowercase_	=    ["pixel_values"]

 def __init__(self       :     Tuple ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     PILImageResampling = PILImageResampling.BILINEAR ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Union[int, float] = 1 / 255 ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				**UpperCAmelCase_       :     List[Any] ,				) ->None:



   '''simple docstring'''



   super().__init__(**UpperCAmelCase_)
   lowerCamelCase__:   Optional[int]    						=size if size is not None else {"shortest_edge": 256}
   lowerCamelCase__:   Any    						=get_size_dict(UpperCAmelCase_ ,				default_to_square=UpperCAmelCase_)
   lowerCamelCase__:   Tuple    						=crop_size if crop_size is not None else {"height": 224, "width": 224}
   lowerCamelCase__:   Any    						=get_size_dict(UpperCAmelCase_ ,				param_name="crop_size")

   lowerCamelCase__:   str    						=do_resize
   lowerCamelCase__:   Any    						=size
   lowerCamelCase__:   Any    						=do_center_crop
   lowerCamelCase__:   int    						=crop_size
   lowerCamelCase__:   int    						=resample
   lowerCamelCase__:   Optional[int]    						=do_rescale
   lowerCamelCase__:   int    						=rescale_factor
   lowerCamelCase__:   Dict    						=offset
   lowerCamelCase__:   List[Any]    						=do_normalize
   lowerCamelCase__:   Optional[int]    						=image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
   lowerCamelCase__:   List[str]    						=image_std if image_std is not None else IMAGENET_STANDARD_STD

 def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any] ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Dict[str, int] ,				UpperCAmelCase_       :     PILImageResampling = PILImageResampling.BILINEAR ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     List[Any] ,				) ->np.ndarray:



   '''simple docstring'''



   lowerCamelCase__:   Dict    						=get_size_dict(UpperCAmelCase_ ,				default_to_square=UpperCAmelCase_)
   if "shortest_edge" in size:
     lowerCamelCase__:   Union[str, Any]    						=get_resize_output_image_size(UpperCAmelCase_ ,				size["shortest_edge"] ,				default_to_square=UpperCAmelCase_)
   elif "height" in size and "width" in size:
     lowerCamelCase__:   int    						=(size["height"], size["width"])
   else:
     raise ValueError(F"""Size must have 'height' and 'width' or 'shortest_edge' as keys. Got {size.keys()}""")
   return resize(UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     str ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Dict[str, int] ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     List[Any] ,				) ->np.ndarray:



   '''simple docstring'''



   lowerCamelCase__:   List[str]    						=get_size_dict(UpperCAmelCase_)
   if "height" not in size or "width" not in size:
     raise ValueError(F"""Size must have 'height' and 'width' as keys. Got {size.keys()}""")
   return center_crop(UpperCAmelCase_ ,				size=(size["height"], size["width"]) ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Union[str, Any] ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Union[int, float] ,				UpperCAmelCase_       :     bool = True ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     Union[str, Any] ,				) ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:   str    						=image.astype(np.floataa)
   if offset:
     lowerCamelCase__:   List[Any]    						=image - (scale / 2)
   return rescale(UpperCAmelCase_ ,				scale=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple ,				UpperCAmelCase_       :     np.ndarray ,				UpperCAmelCase_       :     Union[float, List[float]] ,				UpperCAmelCase_       :     Union[float, List[float]] ,				UpperCAmelCase_       :     Optional[Union[str, ChannelDimension]] = None ,				**UpperCAmelCase_       :     Union[str, Any] ,				) ->np.ndarray:



   '''simple docstring'''



   return normalize(UpperCAmelCase_ ,				mean=UpperCAmelCase_ ,				std=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				**UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int] ,				UpperCAmelCase_       :     ImageInput ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     PILImageResampling = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     float = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[ChannelDimension] = ChannelDimension.FIRST ,				) ->np.ndarray:



   '''simple docstring'''



   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.")

   if offset and not do_rescale:
     raise ValueError("For offset, do_rescale must also be set to True.")

   # All transformations expect numpy arrays.
   lowerCamelCase__:   List[str]    						=to_numpy_array(UpperCAmelCase_)

   if do_resize:
     lowerCamelCase__:   Optional[Any]    						=self.resize(image=UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_)

   if do_center_crop:
     lowerCamelCase__:   str    						=self.center_crop(UpperCAmelCase_ ,				size=UpperCAmelCase_)

   if do_rescale:
     lowerCamelCase__:   List[str]    						=self.rescale(image=UpperCAmelCase_ ,				scale=UpperCAmelCase_ ,				offset=UpperCAmelCase_)

   if do_normalize:
     lowerCamelCase__:   Dict    						=self.normalize(image=UpperCAmelCase_ ,				mean=UpperCAmelCase_ ,				std=UpperCAmelCase_)

   lowerCamelCase__:   Any    						=to_channel_dimension_format(UpperCAmelCase_ ,				UpperCAmelCase_)
   return image







 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[Any] ,				UpperCAmelCase_       :     ImageInput ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     PILImageResampling = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Dict[str, int] = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     float = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     bool = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[Union[float, List[float]]] = None ,				UpperCAmelCase_       :     Optional[Union[str, TensorType]] = None ,				UpperCAmelCase_       :     ChannelDimension = ChannelDimension.FIRST ,				**UpperCAmelCase_       :     List[str] ,				) ->PIL.Image.Image:



   '''simple docstring'''



   lowerCamelCase__:   Union[str, Any]    						=do_resize if do_resize is not None else self.do_resize
   lowerCamelCase__:   Optional[int]    						=resample if resample is not None else self.resample
   lowerCamelCase__:   Optional[int]    						=do_center_crop if do_center_crop is not None else self.do_center_crop
   lowerCamelCase__:   List[str]    						=do_rescale if do_rescale is not None else self.do_rescale
   lowerCamelCase__:   Dict    						=rescale_factor if rescale_factor is not None else self.rescale_factor
   lowerCamelCase__:   Union[str, Any]    						=offset if offset is not None else self.offset
   lowerCamelCase__:   Dict    						=do_normalize if do_normalize is not None else self.do_normalize
   lowerCamelCase__:   Optional[int]    						=image_mean if image_mean is not None else self.image_mean
   lowerCamelCase__:   List[Any]    						=image_std if image_std is not None else self.image_std

   lowerCamelCase__:   List[Any]    						=size if size is not None else self.size
   lowerCamelCase__:   Optional[int]    						=get_size_dict(UpperCAmelCase_ ,				default_to_square=UpperCAmelCase_)
   lowerCamelCase__:   str    						=crop_size if crop_size is not None else self.crop_size
   lowerCamelCase__:   Optional[Any]    						=get_size_dict(UpperCAmelCase_ ,				param_name="crop_size")

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

   lowerCamelCase__:   str    						=make_batched(UpperCAmelCase_)

   lowerCamelCase__:   Any    						=[
       [
           self._preprocess_image(
               image=UpperCAmelCase_ ,				do_resize=UpperCAmelCase_ ,				size=UpperCAmelCase_ ,				resample=UpperCAmelCase_ ,				do_center_crop=UpperCAmelCase_ ,				crop_size=UpperCAmelCase_ ,				do_rescale=UpperCAmelCase_ ,				rescale_factor=UpperCAmelCase_ ,				offset=UpperCAmelCase_ ,				do_normalize=UpperCAmelCase_ ,				image_mean=UpperCAmelCase_ ,				image_std=UpperCAmelCase_ ,				data_format=UpperCAmelCase_ ,				)
           for img in video
       ]
       for video in videos
   ]

   lowerCamelCase__:   int    						={"pixel_values": videos}
   return BatchFeature(data=UpperCAmelCase_ ,				tensor_type=UpperCAmelCase_)

