


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 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]=None      ,					SCREAMING_SNAKE_CASE__      : List[Any]=None    ):
     # Recurse if needed
     if "." in tensor_name:
          __UpperCamelCase   							=tensor_name.split('.'    )
          for split in splits[:-1]:
               __UpperCamelCase   							=getattr(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
               if new_module is None:
                    raise ValueError(F'{module} has no attribute {split}.'    )
               __UpperCamelCase   							=new_module
          __UpperCamelCase   							=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}.'    )
     __UpperCamelCase   							=tensor_name in module._buffers
     __UpperCamelCase   							=getattr(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     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}.'    )

     __UpperCamelCase   							=False
     __UpperCamelCase   							=False
     if is_buffer or not is_bitsandbytes_available():
          __UpperCamelCase   							=False
          __UpperCamelCase   							=False
     else:
          __UpperCamelCase   							=hasattr(bnb.nn      ,					'Params4bit'    ) and isinstance(module._parameters[tensor_name]      ,					bnb.nn.Paramsabit    )
          __UpperCamelCase   							=isinstance(module._parameters[tensor_name]      ,					bnb.nn.IntaParams    )

     if is_abit or is_abit:
          __UpperCamelCase   							=module._parameters[tensor_name]
          if param.device.type != "cuda":
               if value is None:
                    __UpperCamelCase   							=old_value.to(SCREAMING_SNAKE_CASE__    )
               elif isinstance(SCREAMING_SNAKE_CASE__      ,					torch.Tensor    ):
                    __UpperCamelCase   							=value.to('cpu'    )
                    if value.dtype == torch.inta:
                         __UpperCamelCase   							=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:
                    __UpperCamelCase   							=torch.tensor(SCREAMING_SNAKE_CASE__      ,					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      ,					SCREAMING_SNAKE_CASE__    ) and fpaa_statistics is None:
                    __UpperCamelCase   							=new_value.T

               __UpperCamelCase   							=old_value.__dict__
               if is_abit:
                    __UpperCamelCase   							=bnb.nn.IntaParams(SCREAMING_SNAKE_CASE__      ,					requires_grad=SCREAMING_SNAKE_CASE__      ,					**SCREAMING_SNAKE_CASE__    ).to(SCREAMING_SNAKE_CASE__    )
               elif is_abit:
                    __UpperCamelCase   							=bnb.nn.Paramsabit(SCREAMING_SNAKE_CASE__      ,					requires_grad=SCREAMING_SNAKE_CASE__      ,					**SCREAMING_SNAKE_CASE__    ).to(SCREAMING_SNAKE_CASE__    )

               __UpperCamelCase   							=new_value
               if fpaa_statistics is not None:
                    setattr(module.weight      ,					'SCB'      ,					fpaa_statistics.to(SCREAMING_SNAKE_CASE__    )    )

     else:
          if value is None:
               __UpperCamelCase   							=old_value.to(SCREAMING_SNAKE_CASE__    )
          elif isinstance(SCREAMING_SNAKE_CASE__      ,					torch.Tensor    ):
               __UpperCamelCase   							=value.to(SCREAMING_SNAKE_CASE__    )
          else:
               __UpperCamelCase   							=torch.tensor(SCREAMING_SNAKE_CASE__      ,					device=SCREAMING_SNAKE_CASE__    )

          if is_buffer:
               __UpperCamelCase   							=new_value
          else:
               __UpperCamelCase   							=nn.Parameter(SCREAMING_SNAKE_CASE__      ,					requires_grad=old_value.requires_grad    )
               __UpperCamelCase   							=new_value

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict      ,					SCREAMING_SNAKE_CASE__      : List[Any]=None      ,					SCREAMING_SNAKE_CASE__      : Optional[int]=None      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]=None      ,					SCREAMING_SNAKE_CASE__      : str=False    ):
     for name, module in model.named_children():
          if current_key_name is None:
               __UpperCamelCase   							=[]
          current_key_name.append(SCREAMING_SNAKE_CASE__    )

          if (isinstance(SCREAMING_SNAKE_CASE__      ,					nn.Linear    ) or isinstance(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )) 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(SCREAMING_SNAKE_CASE__    ) for key in modules_to_not_convert    ):
                    with init_empty_weights():
                         if isinstance(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    ):
                              __UpperCamelCase							,				__UpperCamelCase   							=module.weight.shape
                         else:
                              __UpperCamelCase   							=module.in_features
                              __UpperCamelCase   							=module.out_features

                         if quantization_config.quantization_method() == "llm_int8":
                              __UpperCamelCase   							=bnb.nn.LinearabitLt(
                                  SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					module.bias is not None      ,					has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight      ,					threshold=quantization_config.llm_inta_threshold      ,					)
                              __UpperCamelCase   							=True
                         else:
                              if (
                                  quantization_config.llm_inta_skip_modules is not None
                                  and name in quantization_config.llm_inta_skip_modules
                              ):
                                   pass
                              else:
                                   __UpperCamelCase   							=bnb.nn.Linearabit(
                                       SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					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      ,					)
                                   __UpperCamelCase   							=True
                    # Store the module class in case we need to transpose the weight later
                         __UpperCamelCase   							=type(SCREAMING_SNAKE_CASE__    )
                         # Force requires grad to False to avoid unexpected errors
                         model._modules[name].requires_grad_(SCREAMING_SNAKE_CASE__    )
          if len(list(module.children()    )    ) > 0:
               __UpperCamelCase							,				__UpperCamelCase   							=_replace_with_bnb_linear(
                   SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					has_been_replaced=SCREAMING_SNAKE_CASE__      ,					)
          # Remove the last key for recursion
          current_key_name.pop(-1    )
     return model, has_been_replaced

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]=None      ,					SCREAMING_SNAKE_CASE__      : List[str]=None      ,					SCREAMING_SNAKE_CASE__      : List[Any]=None    ):
     __UpperCamelCase   							=['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
     __UpperCamelCase							,				__UpperCamelCase   							=_replace_with_bnb_linear(
         SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )

     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 						_UpperCAmelCase    (      *SCREAMING_SNAKE_CASE__      : Any      ,					**SCREAMING_SNAKE_CASE__      : List[str]    ):
     warnings.warn(
         '`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead'      ,					SCREAMING_SNAKE_CASE__      ,					)
     return replace_with_bnb_linear(*SCREAMING_SNAKE_CASE__      ,					**SCREAMING_SNAKE_CASE__    )

def 						_UpperCAmelCase    (      *SCREAMING_SNAKE_CASE__      : Dict      ,					**SCREAMING_SNAKE_CASE__      : Any    ):
     warnings.warn(
         '`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead'      ,					SCREAMING_SNAKE_CASE__      ,					)
     return set_module_quantized_tensor_to_device(*SCREAMING_SNAKE_CASE__      ,					**SCREAMING_SNAKE_CASE__    )





def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Tuple    ):
     __UpperCamelCase   							=deepcopy(SCREAMING_SNAKE_CASE__    )  # this has 0 cost since it is done inside `init_empty_weights` context manager`
     tied_model.tie_weights()

     __UpperCamelCase   							=find_tied_parameters(SCREAMING_SNAKE_CASE__    )
     # For compatibility with Accelerate < 0.18
     if isinstance(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    ):
          __UpperCamelCase   							=sum(list(tied_params.values()    )      ,					[]    ) + list(tied_params.keys()    )
     else:
          __UpperCamelCase   							=sum(SCREAMING_SNAKE_CASE__      ,					[]    )
     __UpperCamelCase   							=len(SCREAMING_SNAKE_CASE__    ) > 0

     # Check if it is a base model
     __UpperCamelCase   							=not hasattr(SCREAMING_SNAKE_CASE__      ,					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
     __UpperCamelCase   							=list(model.named_children()    )
     __UpperCamelCase   							=[list_modules[-1][0]]

     # add last module together with tied weights
     __UpperCamelCase   							=set(SCREAMING_SNAKE_CASE__    ) - set(SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=list(set(SCREAMING_SNAKE_CASE__    )    ) + list(SCREAMING_SNAKE_CASE__    )

     # remove ".weight" from the keys
     __UpperCamelCase   							=['.weight', '.bias']
     __UpperCamelCase   							=[]
     for name in list_untouched:
          for name_to_remove in names_to_remove:
               if name_to_remove in name:
                    __UpperCamelCase   							=name.replace(SCREAMING_SNAKE_CASE__      ,					''    )
          filtered_module_names.append(SCREAMING_SNAKE_CASE__    )

     return filtered_module_names









import json
import os
from collections import Counter

import torch
import torchvision
import torchvision.transforms as transforms
from PIL import Image
from torch import nn
from torch.utils.data import Dataset


_A			=						{1: (1, 1), 2: (2, 1), 3: (3, 1), 4: (2, 2), 5: (5, 1), 6: (3, 2), 7: (7, 1), 8: (4, 2), 9: (3, 3)}






class    UpperCAmelCase__	( nn.Module		):



    """simple docstring"""






    def __init__(      self ,       A_   )  ->	Optional[int]:
         super().__init__()
         __UpperCamelCase   							=torchvision.models.resnetaaa(pretrained=A_   )
         __UpperCamelCase   							=list(model.children()   )[:-2]
         __UpperCamelCase   							=nn.Sequential(*A_   )
         __UpperCamelCase   							=nn.AdaptiveAvgPoolad(POOLING_BREAKDOWN[args.num_image_embeds]   )






    def _a (      self ,       A_   )  ->	int:
         # Bx3x224x224 -> Bx2048x7x7 -> Bx2048xN -> BxNx2048
         __UpperCamelCase   							=self.pool(self.model(A_   )   )
         __UpperCamelCase   							=torch.flatten(A_ ,       start_dim=2   )
         __UpperCamelCase   							=out.transpose(1 ,       2   ).contiguous()
         return out  # BxNx2048






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    def __init__(      self ,       A_ ,       A_ ,       A_ ,       A_ ,       A_   )  ->	List[str]:
         __UpperCamelCase   							=[json.loads(A_   ) for l in open(A_   )]
         __UpperCamelCase   							=os.path.dirname(A_   )
         __UpperCamelCase   							=tokenizer
         __UpperCamelCase   							=labels
         __UpperCamelCase   							=len(A_   )
         __UpperCamelCase   							=max_seq_length

         __UpperCamelCase   							=transforms






    def __len__(      self   )  ->	Any:
         return len(self.data   )






    def __getitem__(      self ,       A_   )  ->	Union[str, Any]:
         __UpperCamelCase   							=torch.LongTensor(self.tokenizer.encode(self.data[index]['text'] ,       add_special_tokens=A_   )   )
         __UpperCamelCase							,				__UpperCamelCase							,				__UpperCamelCase   							=sentence[0], sentence[1:-1], sentence[-1]
         __UpperCamelCase   							=sentence[: self.max_seq_length]

         __UpperCamelCase   							=torch.zeros(self.n_classes   )
         __UpperCamelCase   							=1

         __UpperCamelCase   							=Image.open(os.path.join(self.data_dir ,       self.data[index]['img']   )   ).convert('RGB'   )
         __UpperCamelCase   							=self.transforms(A_   )

         return {
             "image_start_token": start_token,
             "image_end_token": end_token,
             "sentence": sentence,
             "image": image,
             "label": label,
         }






    def _a (      self   )  ->	List[str]:
         __UpperCamelCase   							=Counter()
         for row in self.data:
              label_freqs.update(row['label']   )
         return label_freqs

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=[len(row['sentence']    ) for row in batch]
     __UpperCamelCase							,				__UpperCamelCase   							=len(SCREAMING_SNAKE_CASE__    ), max(SCREAMING_SNAKE_CASE__    )

     __UpperCamelCase   							=torch.zeros(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					dtype=torch.long    )
     __UpperCamelCase   							=torch.zeros(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__      ,					dtype=torch.long    )

     for i_batch, (input_row, length) in enumerate(zip(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )    ):
          __UpperCamelCase   							=input_row['sentence']
          __UpperCamelCase   							=1

     __UpperCamelCase   							=torch.stack([row['image'] for row in batch]    )
     __UpperCamelCase   							=torch.stack([row['label'] for row in batch]    )
     __UpperCamelCase   							=torch.stack([row['image_start_token'] for row in batch]    )
     __UpperCamelCase   							=torch.stack([row['image_end_token'] for row in batch]    )

     return text_tensor, mask_tensor, img_tensor, img_start_token, img_end_token, tgt_tensor

def 						_UpperCAmelCase    (      ):
     return [
         "Crime",
         "Drama",
         "Thriller",
         "Action",
         "Comedy",
         "Romance",
         "Documentary",
         "Short",
         "Mystery",
         "History",
         "Family",
         "Adventure",
         "Fantasy",
         "Sci-Fi",
         "Western",
         "Horror",
         "Sport",
         "War",
         "Music",
         "Musical",
         "Animation",
         "Biography",
         "Film-Noir",
     ]





def 						_UpperCAmelCase    (      ):
     return transforms.Compose(
         [
             transforms.Resize(2_56    ),
             transforms.CenterCrop(2_24    ),
             transforms.ToTensor(),
             transforms.Normalize(
                 mean=[0.46777044, 0.44531429, 0.40661017]      ,					std=[0.12221994, 0.12145835, 0.14380469]      ,					),
         ]    )





