


import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY







@is_pipeline_test
@require_torch_or_tf
class 	__lowercase    (unittest.TestCase  ):





							"""simple docstring"""







							_UpperCAmelCase      =						MODEL_FOR_CAUSAL_LM_MAPPING
							_UpperCAmelCase      =						TF_MODEL_FOR_CAUSAL_LM_MAPPING






							@require_torch
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					pipeline(task='text-generation'			,						model='sshleifer/tiny-ctrl'			,						framework='pt'       )
										# Using `do_sample=False` to force deterministic output
										SCREAMING_SNAKE_CASE_		:     int					=					text_generator('This is a test'			,						do_sample=lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'generated_text': (
										                'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
										                ' oscope. FiliFili@@'
										            )
										        }
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     Tuple					=					text_generator(['This is a test', 'This is a second test']       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        [
										            {
										                'generated_text': (
										                    'This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'
										                    ' oscope. FiliFili@@'
										                )
										            }
										        ],
										        [
										            {
										                'generated_text': (
										                    'This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'
										                    ' oscope. oscope. FiliFili@@'
										                )
										            }
										        ],
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     Any					=					text_generator('This is a test'			,						do_sample=lowerCAmelCase__			,						num_return_sequences=2			,						return_tensors=lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {'generated_token_ids': ANY(lowerCAmelCase__       )},
										        {'generated_token_ids': ANY(lowerCAmelCase__       )},
										    ]			,						)
										SCREAMING_SNAKE_CASE_		:     List[Any]					=					text_generator.model.config.eos_token_id
										SCREAMING_SNAKE_CASE_		:     Any					=					"<pad>"
										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					text_generator(
										    ['This is a test', 'This is a second test']			,						do_sample=lowerCAmelCase__			,						num_return_sequences=2			,						batch_size=2			,						return_tensors=lowerCAmelCase__			,						)
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        [
										            {'generated_token_ids': ANY(lowerCAmelCase__       )},
										            {'generated_token_ids': ANY(lowerCAmelCase__       )},
										        ],
										        [
										            {'generated_token_ids': ANY(lowerCAmelCase__       )},
										            {'generated_token_ids': ANY(lowerCAmelCase__       )},
										        ],
										    ]			,						)






							@require_tf
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[Any]					=					pipeline(task='text-generation'			,						model='sshleifer/tiny-ctrl'			,						framework='tf'       )

										# Using `do_sample=False` to force deterministic output
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					text_generator('This is a test'			,						do_sample=lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'generated_text': (
										                'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
										                ' please,'
										            )
										        }
										    ]			,						)

										SCREAMING_SNAKE_CASE_		:     Dict					=					text_generator(['This is a test', 'This is a second test']			,						do_sample=lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        [
										            {
										                'generated_text': (
										                    'This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'
										                    ' please,'
										                )
										            }
										        ],
										        [
										            {
										                'generated_text': (
										                    'This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'
										                    ' Cannes 閲閲Cannes Cannes Cannes 攵 please,'
										                )
										            }
										        ],
										    ]			,						)






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     str					=					TextGenerationPipeline(model=lowerCAmelCase__			,						tokenizer=lowerCAmelCase__       )
										return text_generator, ["This is a test", "Another test"]






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     Dict					=					"Hello I believe in"
										SCREAMING_SNAKE_CASE_		:     Any					=					pipeline('text-generation'			,						model='hf-internal-testing/tiny-random-gpt2'       )
										SCREAMING_SNAKE_CASE_		:     Dict					=					text_generator(lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[{'generated_text': 'Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'}]			,						)

										SCREAMING_SNAKE_CASE_		:     int					=					text_generator(lowerCAmelCase__			,						stop_sequence=' fe'       )
										self.assertEqual(lowerCAmelCase__			,						[{'generated_text': 'Hello I believe in fe'}]       )






							def 					UpperCamelCase__     (      self			,						lowerCAmelCase__			,						lowerCAmelCase__       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					text_generator.model
										SCREAMING_SNAKE_CASE_		:     List[str]					=					text_generator.tokenizer

										SCREAMING_SNAKE_CASE_		:     Any					=					text_generator('This is a test'       )
										self.assertEqual(lowerCAmelCase__			,						[{'generated_text': ANY(lowerCAmelCase__       )}]       )
										self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

										SCREAMING_SNAKE_CASE_		:     List[str]					=					text_generator('This is a test'			,						return_full_text=lowerCAmelCase__       )
										self.assertEqual(lowerCAmelCase__			,						[{'generated_text': ANY(lowerCAmelCase__       )}]       )
										self.assertNotIn('This is a test'			,						outputs[0]['generated_text']       )

										SCREAMING_SNAKE_CASE_		:     int					=					pipeline(task='text-generation'			,						model=lowerCAmelCase__			,						tokenizer=lowerCAmelCase__			,						return_full_text=lowerCAmelCase__       )
										SCREAMING_SNAKE_CASE_		:     Any					=					text_generator('This is a test'       )
										self.assertEqual(lowerCAmelCase__			,						[{'generated_text': ANY(lowerCAmelCase__       )}]       )
										self.assertNotIn('This is a test'			,						outputs[0]['generated_text']       )

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					text_generator('This is a test'			,						return_full_text=lowerCAmelCase__       )
										self.assertEqual(lowerCAmelCase__			,						[{'generated_text': ANY(lowerCAmelCase__       )}]       )
										self.assertTrue(outputs[0]['generated_text'].startswith('This is a test'       )       )

										SCREAMING_SNAKE_CASE_		:     str					=					text_generator(['This is great !', 'Something else']			,						num_return_sequences=2			,						do_sample=lowerCAmelCase__       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        [{'generated_text': ANY(lowerCAmelCase__       )}, {'generated_text': ANY(lowerCAmelCase__       )}],
										        [{'generated_text': ANY(lowerCAmelCase__       )}, {'generated_text': ANY(lowerCAmelCase__       )}],
										    ]			,						)

										if text_generator.tokenizer.pad_token is not None:
													SCREAMING_SNAKE_CASE_		:     Dict					=					text_generator(
													    ['This is great !', 'Something else']			,						num_return_sequences=2			,						batch_size=2			,						do_sample=lowerCAmelCase__       )
													self.assertEqual(
													    lowerCAmelCase__			,						[
													        [{'generated_text': ANY(lowerCAmelCase__       )}, {'generated_text': ANY(lowerCAmelCase__       )}],
													        [{'generated_text': ANY(lowerCAmelCase__       )}, {'generated_text': ANY(lowerCAmelCase__       )}],
													    ]			,						)

										with self.assertRaises(lowerCAmelCase__       ):
													SCREAMING_SNAKE_CASE_		:     List[Any]					=					text_generator('test'			,						return_full_text=lowerCAmelCase__			,						return_text=lowerCAmelCase__       )
										with self.assertRaises(lowerCAmelCase__       ):
													SCREAMING_SNAKE_CASE_		:     Any					=					text_generator('test'			,						return_full_text=lowerCAmelCase__			,						return_tensors=lowerCAmelCase__       )
										with self.assertRaises(lowerCAmelCase__       ):
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					text_generator('test'			,						return_text=lowerCAmelCase__			,						return_tensors=lowerCAmelCase__       )

										# Empty prompt is slighly special
										# it requires BOS token to exist.
										# Special case for Pegasus which will always append EOS so will
										# work even without BOS.
										if (
										    text_generator.tokenizer.bos_token_id is not None
										    or "Pegasus" in tokenizer.__class__.__name__
										    or "Git" in model.__class__.__name__
										):
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					text_generator(''       )
													self.assertEqual(lowerCAmelCase__			,						[{'generated_text': ANY(lowerCAmelCase__       )}]       )
										else:
													with self.assertRaises((ValueError, AssertionError)       ):
																SCREAMING_SNAKE_CASE_		:     str					=					text_generator(''       )

										if text_generator.framework == "tf":
													# TF generation does not support max_new_tokens, and it's impossible
													# to control long generation with only max_length without
													# fancy calculation, dismissing tests for now.
													return
										# We don't care about infinite range models.
										# They already work.
										# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					["RwkvForCausalLM", "XGLMForCausalLM", "GPTNeoXForCausalLM"]
										if (
										    tokenizer.model_max_length < 1_0_0_0_0
										    and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
										):
													# Handling of large generations
													with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)       ):
																text_generator('This is a test' * 5_0_0			,						max_new_tokens=2_0       )

													SCREAMING_SNAKE_CASE_		:     List[str]					=					text_generator('This is a test' * 5_0_0			,						handle_long_generation='hole'			,						max_new_tokens=2_0       )
													# Hole strategy cannot work
													with self.assertRaises(lowerCAmelCase__       ):
																text_generator(
																    'This is a test' * 5_0_0			,						handle_long_generation='hole'			,						max_new_tokens=tokenizer.model_max_length + 1_0			,						)






							@require_torch
							@require_accelerate
							@require_torch_gpu
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										import torch

										# Classic `model_kwargs`
										SCREAMING_SNAKE_CASE_		:     int					=					pipeline(
										    model='hf-internal-testing/tiny-random-bloom'			,						model_kwargs={'device_map': 'auto', 'torch_dtype': torch.bfloataa}			,						)
										self.assertEqual(pipe.model.device			,						torch.device(0       )       )
										self.assertEqual(pipe.model.lm_head.weight.dtype			,						torch.bfloataa       )
										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					pipe('This is a test'       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'generated_text': (
										                'This is a test test test test test test test test test test test test test test test test'
										                ' test'
										            )
										        }
										    ]			,						)

										# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
										SCREAMING_SNAKE_CASE_		:     Optional[int]					=					pipeline(model='hf-internal-testing/tiny-random-bloom'			,						device_map='auto'			,						torch_dtype=torch.bfloataa       )
										self.assertEqual(pipe.model.device			,						torch.device(0       )       )
										self.assertEqual(pipe.model.lm_head.weight.dtype			,						torch.bfloataa       )
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					pipe('This is a test'       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'generated_text': (
										                'This is a test test test test test test test test test test test test test test test test'
										                ' test'
										            )
										        }
										    ]			,						)

										# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
										SCREAMING_SNAKE_CASE_		:     List[str]					=					pipeline(model='hf-internal-testing/tiny-random-bloom'			,						device_map='auto'       )
										self.assertEqual(pipe.model.device			,						torch.device(0       )       )
										self.assertEqual(pipe.model.lm_head.weight.dtype			,						torch.floataa       )
										SCREAMING_SNAKE_CASE_		:     str					=					pipe('This is a test'       )
										self.assertEqual(
										    lowerCAmelCase__			,						[
										        {
										            'generated_text': (
										                'This is a test test test test test test test test test test test test test test test test'
										                ' test'
										            )
										        }
										    ]			,						)






							@require_torch
							@require_torch_gpu
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										import torch

										SCREAMING_SNAKE_CASE_		:     str					=					pipeline(model='hf-internal-testing/tiny-random-bloom'			,						device=0			,						torch_dtype=torch.floataa       )
										pipe('This is a test'       )






							@require_torch
							@require_accelerate
							@require_torch_gpu
							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										import torch

										SCREAMING_SNAKE_CASE_		:     Optional[Any]					=					pipeline(model='hf-internal-testing/tiny-random-bloom'			,						device_map='auto'			,						torch_dtype=torch.floataa       )
										pipe('This is a test'			,						do_sample=lowerCAmelCase__			,						top_p=0.5       )






							def 					UpperCamelCase__     (      self       ):





										"""simple docstring"""




										SCREAMING_SNAKE_CASE_		:     List[str]					=					"Hello world"
										SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					pipeline('text-generation'			,						model='hf-internal-testing/tiny-random-gpt2'       )
										if text_generator.model.framework == "tf":
													SCREAMING_SNAKE_CASE_		:     Union[str, Any]					=					logging.get_logger('transformers.generation.tf_utils'       )
										else:
													SCREAMING_SNAKE_CASE_		:     str					=					logging.get_logger('transformers.generation.utils'       )
										SCREAMING_SNAKE_CASE_		:     Any					=					"Both `max_new_tokens`"  # The beggining of the message to be checked in this test

										# Both are set by the user -> log warning
										with CaptureLogger(lowerCAmelCase__       ) as cl:
													SCREAMING_SNAKE_CASE_		:     int					=					text_generator(lowerCAmelCase__			,						max_length=1_0			,						max_new_tokens=1       )
										self.assertIn(lowerCAmelCase__			,						cl.out       )

										# The user only sets one -> no warning
										with CaptureLogger(lowerCAmelCase__       ) as cl:
													SCREAMING_SNAKE_CASE_		:     Optional[int]					=					text_generator(lowerCAmelCase__			,						max_new_tokens=1       )
										self.assertNotIn(lowerCAmelCase__			,						cl.out       )

										with CaptureLogger(lowerCAmelCase__       ) as cl:
													SCREAMING_SNAKE_CASE_		:     str					=					text_generator(lowerCAmelCase__			,						max_length=1_0       )
										self.assertNotIn(lowerCAmelCase__			,						cl.out       )







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

UpperCamelCase_						:     int	       =							logging.get_logger(__name__)



def 		UpperCamelCase     (       _UpperCAmelCase  :   Optional[Any] ,			_UpperCAmelCase  :   Optional[Any] ,			_UpperCAmelCase  :   Optional[Any] ,			_UpperCAmelCase  :   Dict=None ,			_UpperCAmelCase  :   Dict=None  )   ->			Tuple:






						'''simple docstring'''

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

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

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

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

																		_lowercase       :	List[str]           =   old_value.__dict__
																		if is_abit:
																								_lowercase       :	Optional[Any]           =   bnb.nn.IntaParams(_UpperCAmelCase ,			requires_grad=_UpperCAmelCase ,			**_UpperCAmelCase  ).to(_UpperCAmelCase  )
																		elif is_abit:
																								_lowercase       :	Dict           =   bnb.nn.Paramsabit(_UpperCAmelCase ,			requires_grad=_UpperCAmelCase ,			**_UpperCAmelCase  ).to(_UpperCAmelCase  )

																		_lowercase       :	str           =   new_value
																		if fpaa_statistics is not None:
																								setattr(module.weight ,			"SCB" ,			fpaa_statistics.to(_UpperCAmelCase  )  )

						else:
												if value is None:
																		_lowercase       :	Optional[Any]           =   old_value.to(_UpperCAmelCase  )
												elif isinstance(_UpperCAmelCase ,			torch.Tensor  ):
																		_lowercase       :	Tuple           =   value.to(_UpperCAmelCase  )
												else:
																		_lowercase       :	Optional[Any]           =   torch.tensor(_UpperCAmelCase ,			device=_UpperCAmelCase  )

												if is_buffer:
																		_lowercase       :	str           =   new_value
												else:
																		_lowercase       :	int           =   nn.Parameter(_UpperCAmelCase ,			requires_grad=old_value.requires_grad  )
																		_lowercase       :	str           =   new_value



def 		UpperCamelCase     (       _UpperCAmelCase  :   Any ,			_UpperCAmelCase  :   str=None ,			_UpperCAmelCase  :   List[str]=None ,			_UpperCAmelCase  :   Tuple=None ,			_UpperCAmelCase  :   Tuple=False  )   ->			int:






						'''simple docstring'''

						for name, module in model.named_children():
												if current_key_name is None:
																		_lowercase       :	int           =   []
												current_key_name.append(_UpperCAmelCase  )

												if (isinstance(_UpperCAmelCase ,			nn.Linear  ) or isinstance(_UpperCAmelCase ,			_UpperCAmelCase  )) 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(_UpperCAmelCase  ) for key in modules_to_not_convert  ):
																								with init_empty_weights():
																														if isinstance(_UpperCAmelCase ,			_UpperCAmelCase  ):
																																				_lowercase      ,    _lowercase       :	Tuple           =   module.weight.shape
																														else:
																																				_lowercase       :	List[Any]           =   module.in_features
																																				_lowercase       :	List[str]           =   module.out_features

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



def 		UpperCamelCase     (       _UpperCAmelCase  :   Optional[int] ,			_UpperCAmelCase  :   Tuple=None ,			_UpperCAmelCase  :   Optional[int]=None ,			_UpperCAmelCase  :   int=None  )   ->			Optional[int]:






						'''simple docstring'''

						_lowercase       :	str           =   ["lm_head"] if modules_to_not_convert is None else modules_to_not_convert
						_lowercase      ,    _lowercase       :	Any           =   _replace_with_bnb_linear(
						    _UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase ,			_UpperCAmelCase  )

						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     (       *_UpperCAmelCase  :   Optional[Any] ,			**_UpperCAmelCase  :   Dict  )   ->			Tuple:






						'''simple docstring'''

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



def 		UpperCamelCase     (       *_UpperCAmelCase  :   Dict ,			**_UpperCAmelCase  :   Dict  )   ->			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" ,			_UpperCAmelCase ,			)
						return set_module_quantized_tensor_to_device(*_UpperCAmelCase ,			**_UpperCAmelCase  )



def 		UpperCamelCase     (       _UpperCAmelCase  :   List[Any]  )   ->			Tuple:






						'''simple docstring'''

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

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

						# Check if it is a base model
						_lowercase       :	Any           =   not hasattr(_UpperCAmelCase ,			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
						_lowercase       :	int           =   list(model.named_children()  )
						_lowercase       :	str           =   [list_modules[-1][0]]

						# add last module together with tied weights
						_lowercase       :	Optional[int]           =   set(_UpperCAmelCase  ) - set(_UpperCAmelCase  )
						_lowercase       :	Optional[int]           =   list(set(_UpperCAmelCase  )  ) + list(_UpperCAmelCase  )

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

						return filtered_module_names




