


'''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_					:    Dict          =    logging.get_logger(__name__)






def 	_A				(lowerCAmelCase__  :List[str]				,						lowerCAmelCase__  :int				,						lowerCAmelCase__  :str				,						lowerCAmelCase__  :Any=None				,						lowerCAmelCase__  :Dict=None		)   ->  Optional[Any]:




     '''simple docstring'''



     if "." in tensor_name:
          _a			      =							tensor_name.split('.'		)
          for split in splits[:-1]:
               _a			      =							getattr(lowerCAmelCase__				,						lowerCAmelCase__		)
               if new_module is None:
                    raise ValueError(f'{module} has no attribute {split}.'		)
               _a			      =							new_module
          _a			      =							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}.'		)
     _a			      =							tensor_name in module._buffers
     _a			      =							getattr(lowerCAmelCase__				,						lowerCAmelCase__		)

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

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

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

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

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

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

          if is_buffer:
               _a			      =							new_value
          else:
               _a			      =							nn.Parameter(lowerCAmelCase__				,						requires_grad=old_value.requires_grad		)
               _a			      =							new_value






def 	_A				(lowerCAmelCase__  :List[Any]				,						lowerCAmelCase__  :Tuple=None				,						lowerCAmelCase__  :Union[str, Any]=None				,						lowerCAmelCase__  :int=None				,						lowerCAmelCase__  :Optional[Any]=False		)   ->  List[str]:




     '''simple docstring'''



     for name, module in model.named_children():
          if current_key_name is None:
               _a			      =							[]
          current_key_name.append(lowerCAmelCase__		)

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

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






def 	_A				(lowerCAmelCase__  :str				,						lowerCAmelCase__  :Optional[int]=None				,						lowerCAmelCase__  :Tuple=None				,						lowerCAmelCase__  :List[Any]=None		)   ->  str:




     '''simple docstring'''



     _a			      =							['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
     _a      ,   _a			      =							_replace_with_bnb_linear(
         lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__				,						lowerCAmelCase__		)

     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 	_A				(*lowerCAmelCase__  :List[str]				,						**lowerCAmelCase__  :str		)   ->  int:




     '''simple docstring'''



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






def 	_A				(*lowerCAmelCase__  :Optional[Any]				,						**lowerCAmelCase__  :int		)   ->  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'				,						lowerCAmelCase__				,						)
     return set_module_quantized_tensor_to_device(*lowerCAmelCase__				,						**lowerCAmelCase__		)






def 	_A				(lowerCAmelCase__  :Tuple		)   ->  int:




     '''simple docstring'''



     _a			      =							deepcopy(lowerCAmelCase__		)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
     tied_model.tie_weights()

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

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

     # add last module together with tied weights
     _a			      =							set(lowerCAmelCase__		) - set(lowerCAmelCase__		)
     _a			      =							list(set(lowerCAmelCase__		)		) + list(lowerCAmelCase__		)

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

     return filtered_module_names





'''simple docstring'''






import datasets


a_					:    List[Any]          =    "\\n@InProceedings{conneau2018xnli,\n  author = \"Conneau, Alexis\n                 and Rinott, Ruty\n                 and Lample, Guillaume\n                 and Williams, Adina\n                 and Bowman, Samuel R.\n                 and Schwenk, Holger\n                 and Stoyanov, Veselin\",\n  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",\n  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods\n               in Natural Language Processing\",\n  year = \"2018\",\n  publisher = \"Association for Computational Linguistics\",\n  location = \"Brussels, Belgium\",\n}\n"

a_					:    Optional[Any]          =    "\\nXNLI is a subset of a few thousand examples from MNLI which has been translated\ninto a 14 different languages (some low-ish resource). As with MNLI, the goal is\nto predict textual entailment (does sentence A imply/contradict/neither sentence\nB) and is a classification task (given two sentences, predict one of three\nlabels).\n"

a_					:    Optional[Any]          =    "\nComputes XNLI score which is just simple accuracy.\nArgs:\n    predictions: Predicted labels.\n    references: Ground truth labels.\nReturns:\n    'accuracy': accuracy\nExamples:\n\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> xnli_metric = datasets.load_metric(\"xnli\")\n    >>> results = xnli_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n"






def 	_A				(lowerCAmelCase__  :List[Any]				,						lowerCAmelCase__  :Tuple		)   ->  Dict:




     '''simple docstring'''



     return (preds == labels).mean()






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,				_KWARGS_DESCRIPTION       )
class  a     (     datasets.Metric       ):
 def 							__UpperCAmelCase		( self						)					->							Dict:
      return datasets.MetricInfo(
          description=_DESCRIPTION      ,				citation=_CITATION      ,				inputs_description=_KWARGS_DESCRIPTION      ,				features=datasets.Features(
              {
                  'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'						),
                  'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'						),
              }						)      ,				codebase_urls=[]      ,				reference_urls=[]      ,				format='numpy'      ,				)




 def 							__UpperCAmelCase		( self      ,				__magic_name__      ,				__magic_name__						)					->							Dict:
      return {"accuracy": simple_accuracy(__magic_name__      ,				__magic_name__						)}

