
'''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

lowerCAmelCase					:    Optional[int]           = logging.get_logger(__name__)







def 		A_(     A						:		Optional[int]		,     A						:		Any		,     A						:		Union[str, Any]		,     A						:		Optional[int]=None		,     A						:		List[str]=None):
							# Recurse if needed
							if "." in tensor_name:
														UpperCamelCase   			=     tensor_name.split('.')
														for split in splits[:-1]:
																					UpperCamelCase   			=     getattr(A		,     A)
																					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(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}.''')

							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(A)
																					elif isinstance(A		,     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(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:
																												UpperCamelCase   			=     new_value.T

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

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

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

														if is_buffer:
																					UpperCamelCase   			=     new_value
														else:
																					UpperCamelCase   			=     nn.Parameter(A		,     requires_grad=old_value.requires_grad)
																					UpperCamelCase   			=     new_value







def 		A_(     A						:		Union[str, Any]		,     A						:		str=None		,     A						:		List[str]=None		,     A						:		str=None		,     A						:		Dict=False):
							for name, module in model.named_children():
														if current_key_name is None:
																					UpperCamelCase   			=     []
														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):
																																										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(
																																										    A		,     A		,     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(
																																																	    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		,     )
																																																	UpperCamelCase   			=     True
                    # Store the module class in case we need to transpose the weight later
																																			UpperCamelCase   			=     type(A)
																																			# Force requires grad to False to avoid unexpected errors
																																			model._modules[name].requires_grad_(A)
														if len(list(module.children())) > 0:
																					UpperCamelCase			,	UpperCamelCase   			=     _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 		A_(     A						:		Union[str, Any]		,     A						:		List[Any]=None		,     A						:		Optional[Any]=None		,     A						:		str=None):
							UpperCamelCase   			=     ['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
							UpperCamelCase			,	UpperCamelCase   			=     _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 		A_(     *A						:		Tuple		,     **A						:		Optional[int]):
							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 		A_(     *A						:		List[str]		,     **A						:		Tuple):
							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 		A_(     A						:		int):
							UpperCamelCase   			=     deepcopy(A)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
							tied_model.tie_weights()

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

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

							# add last module together with tied weights
							UpperCamelCase   			=     set(A) - set(A)
							UpperCamelCase   			=     list(set(A)) + list(A)

							# 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(A		,     '')
														filtered_module_names.append(A)

							return filtered_module_names






"""simple docstring"""






import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test





class 				a__					(						unittest.TestCase       ):



     @parameterized.expand([(None,), ('foo.json',)]   )
     def  lowerCamelCase_						(							self :Union[str, Any]      ,  _lowerCamelCase :Any   ):







      '''simple docstring'''



      UpperCamelCase_     :					str   	=GenerationConfig(
          do_sample=_lowerCamelCase      ,  temperature=0.7      ,  length_penalty=1.0      ,  bad_words_ids=[[1, 2, 3], [4, 5]]      ,  )
      with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(_lowerCamelCase      ,  config_name=_lowerCamelCase   )
       UpperCamelCase_     :					Union[str, Any]   	=GenerationConfig.from_pretrained(_lowerCamelCase      ,  config_name=_lowerCamelCase   )

      # Checks parameters that were specified
      self.assertEqual(loaded_config.do_sample      ,  _lowerCamelCase   )
      self.assertEqual(loaded_config.temperature      ,  0.7   )
      self.assertEqual(loaded_config.length_penalty      ,  1.0   )
      self.assertEqual(loaded_config.bad_words_ids      ,  [[1, 2, 3], [4, 5]]   )

      # Checks parameters that were not specified (defaults)
      self.assertEqual(loaded_config.top_k      ,  50   )
      self.assertEqual(loaded_config.max_length      ,  20   )
      self.assertEqual(loaded_config.max_time      ,  _lowerCamelCase   )



     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Optional[int]   	=AutoConfig.from_pretrained('gpt2'   )
      UpperCamelCase_     :					Tuple   	=GenerationConfig.from_model_config(_lowerCamelCase   )
      UpperCamelCase_     :					Optional[int]   	=GenerationConfig()

      # The generation config has loaded a few non-default parameters from the model config
      self.assertNotEqual(_lowerCamelCase      ,  _lowerCamelCase   )

      # One of those parameters is eos_token_id -- check if it matches
      self.assertNotEqual(generation_config_from_model.eos_token_id      ,  default_generation_config.eos_token_id   )
      self.assertEqual(generation_config_from_model.eos_token_id      ,  model_config.eos_token_id   )



     def  lowerCamelCase_						(							self :Tuple   ):







      '''simple docstring'''



      UpperCamelCase_     :					str   	=GenerationConfig()
      UpperCamelCase_     :					Optional[Any]   	={
          'max_new_tokens': 1_024,
          'foo': 'bar',
      }
      UpperCamelCase_     :					Optional[Any]   	=copy.deepcopy(_lowerCamelCase   )
      UpperCamelCase_     :					Optional[int]   	=generation_config.update(**_lowerCamelCase   )

      # update_kwargs was not modified (no side effects)
      self.assertEqual(_lowerCamelCase      ,  _lowerCamelCase   )

      # update_kwargs was used to update the config on valid attributes
      self.assertEqual(generation_config.max_new_tokens      ,  1_024   )

      # `.update()` returns a dictionary of unused kwargs
      self.assertEqual(_lowerCamelCase      ,  {'foo': 'bar'}   )



     def  lowerCamelCase_						(							self :Union[str, Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Union[str, Any]   	=GenerationConfig()
      UpperCamelCase_     :					Union[str, Any]   	='bar'

      with tempfile.TemporaryDirectory('test-generation-config'   ) as tmp_dir:
       generation_config.save_pretrained(_lowerCamelCase   )

       UpperCamelCase_     :					Dict   	=GenerationConfig.from_pretrained(_lowerCamelCase   )
      # update_kwargs was used to update the config on valid attributes
      self.assertEqual(new_config.foo      ,  'bar'   )

      UpperCamelCase_     :					List[str]   	=GenerationConfig.from_model_config(_lowerCamelCase   )
      assert not hasattr(_lowerCamelCase      ,  'foo'   )  # no new kwargs should be initialized if from config




     def  lowerCamelCase_						(							self :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[str]   	=GenerationConfig()
      self.assertEqual(default_config.temperature      ,  1.0   )
      self.assertEqual(default_config.do_sample      ,  _lowerCamelCase   )
      self.assertEqual(default_config.num_beams      ,  1   )

      UpperCamelCase_     :					Tuple   	=GenerationConfig(
          do_sample=_lowerCamelCase      ,  temperature=0.7      ,  length_penalty=1.0      ,  bad_words_ids=[[1, 2, 3], [4, 5]]      ,  )
      self.assertEqual(config.temperature      ,  0.7   )
      self.assertEqual(config.do_sample      ,  _lowerCamelCase   )
      self.assertEqual(config.num_beams      ,  1   )

      with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(_lowerCamelCase   )
       UpperCamelCase_     :					str   	=GenerationConfig.from_pretrained(_lowerCamelCase      ,  temperature=1.0   )

      self.assertEqual(loaded_config.temperature      ,  1.0   )
      self.assertEqual(loaded_config.do_sample      ,  _lowerCamelCase   )
      self.assertEqual(loaded_config.num_beams      ,  1   )  # default value





@is_staging_test
class 				a__					(						unittest.TestCase       ):



     @classmethod
     def  lowerCamelCase_						(							cls :Optional[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Dict   	=TOKEN
      HfFolder.save_token(_lowerCamelCase   )



     @classmethod
     def  lowerCamelCase_						(							cls :List[Any]   ):







      '''simple docstring'''



      try:
       delete_repo(token=cls._token      ,  repo_id='test-generation-config'   )
      except HTTPError:
       pass

      try:
       delete_repo(token=cls._token      ,  repo_id='valid_org/test-generation-config-org'   )
      except HTTPError:
       pass



     def  lowerCamelCase_						(							self :List[Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					List[str]   	=GenerationConfig(
          do_sample=_lowerCamelCase      ,  temperature=0.7      ,  length_penalty=1.0      ,  )
      config.push_to_hub('test-generation-config'      ,  use_auth_token=self._token   )

      UpperCamelCase_     :					List[Any]   	=GenerationConfig.from_pretrained(f'''{USER}/test-generation-config'''   )
      for k, v in config.to_dict().items():
       if k != "transformers_version":
        self.assertEqual(_lowerCamelCase      ,  getattr(_lowerCamelCase      ,  _lowerCamelCase   )   )

        # Reset repo
      delete_repo(token=self._token      ,  repo_id='test-generation-config'   )

      # Push to hub via save_pretrained
      with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(
           _lowerCamelCase      ,  repo_id='test-generation-config'      ,  push_to_hub=_lowerCamelCase      ,  use_auth_token=self._token   )

      UpperCamelCase_     :					Any   	=GenerationConfig.from_pretrained(f'''{USER}/test-generation-config'''   )
      for k, v in config.to_dict().items():
       if k != "transformers_version":
        self.assertEqual(_lowerCamelCase      ,  getattr(_lowerCamelCase      ,  _lowerCamelCase   )   )




     def  lowerCamelCase_						(							self :Union[str, Any]   ):







      '''simple docstring'''



      UpperCamelCase_     :					Union[str, Any]   	=GenerationConfig(
          do_sample=_lowerCamelCase      ,  temperature=0.7      ,  length_penalty=1.0      ,  )
      config.push_to_hub('valid_org/test-generation-config-org'      ,  use_auth_token=self._token   )

      UpperCamelCase_     :					int   	=GenerationConfig.from_pretrained('valid_org/test-generation-config-org'   )
      for k, v in config.to_dict().items():
       if k != "transformers_version":
        self.assertEqual(_lowerCamelCase      ,  getattr(_lowerCamelCase      ,  _lowerCamelCase   )   )

        # Reset repo
      delete_repo(token=self._token      ,  repo_id='valid_org/test-generation-config-org'   )

      # Push to hub via save_pretrained
      with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(
           _lowerCamelCase      ,  repo_id='valid_org/test-generation-config-org'      ,  push_to_hub=_lowerCamelCase      ,  use_auth_token=self._token   )

      UpperCamelCase_     :					Optional[Any]   	=GenerationConfig.from_pretrained('valid_org/test-generation-config-org'   )
      for k, v in config.to_dict().items():
       if k != "transformers_version":
        self.assertEqual(_lowerCamelCase      ,  getattr(_lowerCamelCase      ,  _lowerCamelCase   )   )
