


'''simple docstring'''

import gc
import importlib.metadata
import tempfile
import unittest

from packaging import version

from transformers import (
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    BitsAndBytesConfig,
    pipeline,
)
from transformers.testing_utils import (
    is_torch_available,
    require_accelerate,
    require_bitsandbytes,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)





def lowerCamelCase      (      lowerCAmelCase    :     Union[str, Any]		):





	"""simple docstring"""







	if model.config.model_type == "gpt2":
		return model.transformer.h[0].mlp.c_fc
	return model.transformer.h[0].mlp.dense_ah_to_h


if is_torch_available():
							import torch
							import torch.nn as nn
							class _lowerCamelCase	(						nn.Module							):



									'''simple docstring'''







									def __init__( self		:						str  ,					_A		:						nn.Module  ,					_A		:						int      )  ->			int:
										super().__init__()
										__magic_name__	:   Tuple					     =					module
										__magic_name__	:   Optional[int]					     =					nn.Sequential(
										    nn.Linear(module.in_features  ,					_A  ,					bias=_A      )  ,					nn.Linear(_A  ,					module.out_features  ,					bias=_A      )  ,					)
										__magic_name__	:   Dict					     =					(2.0 / (5 * min(module.in_features  ,					module.out_features      ))) ** 0.5
										nn.init.normal_(self.adapter[0].weight  ,					std=_A      )
										nn.init.zeros_(self.adapter[1].weight      )
										self.adapter.to(module.weight.device      )







									def        __lowerCAmelCase		( self		:						Optional[Any]  ,					_A		:						Union[str, Any]  ,					*_A		:						List[Any]  ,					**_A		:						Any      )  ->			Any:
										return self.module(_A  ,					*_A  ,					**_A      ) + self.adapter(_A      )
@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		A_     :      str				   =    """bigscience/bloom-1b7"""

		# Constant values
		A_     :      Optional[int]				   =    2.109659552692574

		A_     :      Dict				   =    """Hello my name is"""
		A_     :      str				   =    set()
		EXPECTED_OUTPUTS.add("""Hello my name is John and I am a professional photographer. I"""							)
		EXPECTED_OUTPUTS.add("""Hello my name is John.\nI am a friend of your father.\n"""							)
		EXPECTED_OUTPUTS.add("""Hello my name is John Doe, I am a student at the University"""							)
		A_     :      str				   =    10







		def        __lowerCAmelCase		( self		:						str      )  ->			Optional[int]:
			# Models and tokenizer
			__magic_name__	:   List[str]					     =					AutoTokenizer.from_pretrained(self.model_name      )







class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Union[str, Any]:
			super().setUp()

			# Models and tokenizer
			__magic_name__	:   Tuple					     =					AutoModelForCausalLM.from_pretrained(
			    self.model_name  ,					torch_dtype=torch.floataa  ,					device_map='auto'      )
			__magic_name__	:   List[str]					     =					AutoModelForCausalLM.from_pretrained(self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			List[Any]:
			del self.model_fpaa
			del self.model_abit

			gc.collect()
			torch.cuda.empty_cache()







		def        __lowerCAmelCase		( self		:						str      )  ->			Optional[Any]:
			__magic_name__	:   str					     =					self.model_abit.config

			self.assertTrue(hasattr(_A  ,					'quantization_config'      )      )

			__magic_name__	:   Any					     =					config.to_dict()
			__magic_name__	:   Union[str, Any]					     =					config.to_diff_dict()

			__magic_name__	:   List[str]					     =					config.to_json_string()







		def        __lowerCAmelCase		( self		:						Union[str, Any]      )  ->			int:
			from bitsandbytes.nn import Paramsabit

			__magic_name__	:   str					     =					self.model_fpaa.get_memory_footprint()
			__magic_name__	:   Tuple					     =					self.model_abit.get_memory_footprint()

			self.assertAlmostEqual(mem_fpaa / mem_abit  ,					self.EXPECTED_RELATIVE_DIFFERENCE      )
			__magic_name__	:   Tuple					     =					get_some_linear_layer(self.model_abit      )
			self.assertTrue(linear.weight.__class__ == Paramsabit      )







		def        __lowerCAmelCase		( self		:						Dict      )  ->			List[Any]:
			from transformers import TaPreTrainedModel

			self.model_fpaa.get_memory_footprint()
			self.model_abit.get_memory_footprint()

			for name, module in self.model_abit.named_modules():
				if isinstance(_A  ,					torch.nn.Linear      ):
					if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules:
						# 4-bit parameters are packed in uint8 variables
						self.assertTrue(module.weight.dtype == torch.uinta      )







		def        __lowerCAmelCase		( self		:						int      )  ->			Dict:
			__magic_name__	:   Dict					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      )
			__magic_name__	:   Union[str, Any]					     =					self.model_abit.generate(input_ids=encoded_input['input_ids'].to(0      )  ,					max_new_tokens=10      )

			self.assertIn(self.tokenizer.decode(output_sequences[0]  ,					skip_special_tokens=_A      )  ,					self.EXPECTED_OUTPUTS      )







		def        __lowerCAmelCase		( self		:						List[Any]      )  ->			Optional[int]:
			__magic_name__	:   int					     =					BitsAndBytesConfig()
			__magic_name__	:   Any					     =					True

			__magic_name__	:   Dict					     =					AutoModelForCausalLM.from_pretrained(
			    self.model_name  ,					quantization_config=_A  ,					device_map='auto'      )

			__magic_name__	:   str					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      )
			__magic_name__	:   List[str]					     =					model_abit_from_config.generate(
			    input_ids=encoded_input['input_ids'].to(0      )  ,					max_new_tokens=10      )

			self.assertIn(self.tokenizer.decode(output_sequences[0]  ,					skip_special_tokens=_A      )  ,					self.EXPECTED_OUTPUTS      )







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Union[str, Any]:
			with self.assertRaises(_A      ), tempfile.TemporaryDirectory() as tmpdirname:
				self.model_abit.save_pretrained(_A      )







		def        __lowerCAmelCase		( self		:						int      )  ->			Union[str, Any]:
			__magic_name__	:   Any					     =					BitsAndBytesConfig()

			with self.assertRaises(_A      ):
				__magic_name__	:   List[str]					     =					AutoModelForCausalLM.from_pretrained(
				    self.model_name  ,					quantization_config=_A  ,					load_in_abit=_A  ,					device_map='auto'  ,					bnb_abit_quant_type='nf4'  ,					)







		def        __lowerCAmelCase		( self		:						str      )  ->			Any:
			with self.assertRaises(_A      ):
				# Tries with `str`
				self.model_abit.to('cpu'      )

			with self.assertRaises(_A      ):
				# Tries with a `dtype``
				self.model_abit.to(torch.floataa      )

			with self.assertRaises(_A      ):
				# Tries with a `device`
				self.model_abit.to(torch.device('cuda:0'      )      )

			with self.assertRaises(_A      ):
				# Tries with a `device`
				self.model_abit.float()

			with self.assertRaises(_A      ):
				# Tries with a `device`
				self.model_abit.half()

			# Test if we did not break anything
			__magic_name__	:   Dict					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      )

			__magic_name__	:   Dict					     =					self.model_fpaa.to(torch.floataa      )
			__magic_name__	:   int					     =					self.model_fpaa.generate(input_ids=encoded_input['input_ids'].to(0      )  ,					max_new_tokens=10      )

			# Check this does not throw an error
			__magic_name__	:   Optional[Any]					     =					self.model_fpaa.to('cpu'      )

			# Check this does not throw an error
			__magic_name__	:   List[Any]					     =					self.model_fpaa.half()

			# Check this does not throw an error
			__magic_name__	:   str					     =					self.model_fpaa.float()







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Tuple:
			__magic_name__	:   Optional[int]					     =					AutoModelForSeqaSeqLM.from_pretrained('t5-small'  ,					load_in_abit=_A  ,					device_map='auto'      )
			self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa      )







@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class _lowerCamelCase	(						unittest.TestCase							):



		'''simple docstring'''







		@classmethod
		def        __lowerCAmelCase		( cls		:						str      )  ->			List[Any]:
			__magic_name__	:   Optional[Any]					     =					't5-small'
			__magic_name__	:   Optional[Any]					     =					'google/flan-t5-small'  # flan-t5 uses dense-act instead of dense-relu-dense
			__magic_name__	:   int					     =					AutoTokenizer.from_pretrained(cls.model_name      )
			__magic_name__	:   Union[str, Any]					     =					'Translate in German: Hello, my dog is cute'







		def        __lowerCAmelCase		( self		:						Tuple      )  ->			Any:
			gc.collect()
			torch.cuda.empty_cache()







		def        __lowerCAmelCase		( self		:						Dict      )  ->			Dict:
			from transformers import TaForConditionalGeneration

			__magic_name__	:   int					     =					TaForConditionalGeneration._keep_in_fpaa_modules
			__magic_name__	:   Any					     =					None

			# test with `t5-small`
			__magic_name__	:   Union[str, Any]					     =					TaForConditionalGeneration.from_pretrained(self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			__magic_name__	:   Optional[int]					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      ).to(0      )
			__magic_name__	:   Any					     =					model.generate(**_A      )

			# test with `flan-t5-small`
			__magic_name__	:   int					     =					TaForConditionalGeneration.from_pretrained(
			    self.dense_act_model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			__magic_name__	:   Optional[Any]					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      ).to(0      )
			__magic_name__	:   Optional[int]					     =					model.generate(**_A      )
			__magic_name__	:   Any					     =					modules







		def        __lowerCAmelCase		( self		:						str      )  ->			Any:
			import bitsandbytes as bnb

			from transformers import TaForConditionalGeneration

			# test with `t5-small`
			__magic_name__	:   Optional[int]					     =					TaForConditionalGeneration.from_pretrained(self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )

			# there was a bug with decoders - this test checks that it is fixed
			self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q  ,					bnb.nn.Linearabit      )      )

			__magic_name__	:   List[str]					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      ).to(0      )
			__magic_name__	:   Union[str, Any]					     =					model.generate(**_A      )

			# test with `flan-t5-small`
			__magic_name__	:   Any					     =					TaForConditionalGeneration.from_pretrained(
			    self.dense_act_model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			__magic_name__	:   Tuple					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      ).to(0      )
			__magic_name__	:   Dict					     =					model.generate(**_A      )







class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						Tuple      )  ->			Optional[int]:
			super().setUp()
			# model_name
			__magic_name__	:   List[str]					     =					'bigscience/bloom-560m'
			__magic_name__	:   str					     =					't5-small'

			# Different types of model

			__magic_name__	:   List[str]					     =					AutoModel.from_pretrained(self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			# Sequence classification model
			__magic_name__	:   int					     =					AutoModelForSequenceClassification.from_pretrained(
			    self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			# CausalLM model
			__magic_name__	:   Tuple					     =					AutoModelForCausalLM.from_pretrained(self.model_name  ,					load_in_abit=_A  ,					device_map='auto'      )
			# Seq2seq model
			__magic_name__	:   Tuple					     =					AutoModelForSeqaSeqLM.from_pretrained(
			    self.seq_to_seq_name  ,					load_in_abit=_A  ,					device_map='auto'      )







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			Dict:
			del self.base_model
			del self.sequence_model
			del self.model_abit
			del self.seq_to_seq_model

			gc.collect()
			torch.cuda.empty_cache()







		def        __lowerCAmelCase		( self		:						str      )  ->			Optional[int]:
			from bitsandbytes.nn import Paramsabit

			self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit      )

			# Other heads should be nn.Parameter
			self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter      )
			self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter      )
			self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter      )







class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						List[str]      )  ->			Optional[int]:
			super().setUp()







		def        __lowerCAmelCase		( self		:						Optional[int]      )  ->			List[Any]:
			del self.pipe

			gc.collect()
			torch.cuda.empty_cache()







		def        __lowerCAmelCase		( self		:						Optional[Any]      )  ->			List[Any]:
			__magic_name__	:   Optional[int]					     =					pipeline(
			    'text-generation'  ,					model=self.model_name  ,					model_kwargs={'device_map': 'auto', 'load_in_4bit': True, 'torch_dtype': torch.floataa}  ,					max_new_tokens=self.MAX_NEW_TOKENS  ,					)

			# Real second forward pass
			__magic_name__	:   Tuple					     =					self.pipe(self.input_text      )
			self.assertIn(pipeline_output[0]['generated_text']  ,					self.EXPECTED_OUTPUTS      )







@require_torch_multi_gpu
class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						Any      )  ->			List[str]:
			super().setUp()







		def        __lowerCAmelCase		( self		:						Dict      )  ->			int:
			__magic_name__	:   Optional[int]					     =					AutoModelForCausalLM.from_pretrained(
			    self.model_name  ,					load_in_abit=_A  ,					device_map='balanced'      )

			# Check correct device map
			self.assertEqual(set(model_parallel.hf_device_map.values()      )  ,					{0, 1}      )

			# Check that inference pass works on the model
			__magic_name__	:   int					     =					self.tokenizer(self.input_text  ,					return_tensors='pt'      )

			# Second real batch
			__magic_name__	:   Optional[Any]					     =					model_parallel.generate(input_ids=encoded_input['input_ids'].to(0      )  ,					max_new_tokens=10      )
			self.assertIn(self.tokenizer.decode(output_parallel[0]  ,					skip_special_tokens=_A      )  ,					self.EXPECTED_OUTPUTS      )







class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		def        __lowerCAmelCase		( self		:						str      )  ->			int:
			__magic_name__	:   int					     =					'facebook/opt-350m'
			super().setUp()







		def        __lowerCAmelCase		( self		:						Any      )  ->			Tuple:
			if version.parse(importlib.metadata.version('bitsandbytes'      )      ) < version.parse('0.37.0'      ):
				return

			# Step 1: freeze all parameters
			__magic_name__	:   Optional[Any]					     =					AutoModelForCausalLM.from_pretrained(self.model_name  ,					load_in_abit=_A      )

			self.assertEqual(set(model.hf_device_map.values()      )  ,					{torch.cuda.current_device()}      )

			for param in model.parameters():
				__magic_name__	:   Optional[int]					     =					False  # freeze the model - train adapters later
				if param.ndim == 1:
					# cast the small parameters (e.g. layernorm) to fp32 for stability
					__magic_name__	:   Tuple					     =					param.data.to(torch.floataa      )

        # Step 2: add adapters
			for _, module in model.named_modules():
				if "OPTAttention" in repr(type(_A      )      ):
					__magic_name__	:   List[str]					     =					LoRALayer(module.q_proj  ,					rank=16      )
					__magic_name__	:   Tuple					     =					LoRALayer(module.k_proj  ,					rank=16      )
					__magic_name__	:   Optional[int]					     =					LoRALayer(module.v_proj  ,					rank=16      )

        # Step 3: dummy batch
			__magic_name__	:   List[Any]					     =					self.tokenizer('Test batch '  ,					return_tensors='pt'      ).to(0      )

			# Step 4: Check if the gradient is not None
			with torch.cuda.amp.autocast():
				__magic_name__	:   List[str]					     =					model.forward(**_A      )
				out.logits.norm().backward()

			for module in model.modules():
				if isinstance(_A  ,					_A      ):
					self.assertTrue(module.adapter[1].weight.grad is not None      )
					self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0      )
				elif isinstance(_A  ,					nn.Embedding      ):
					self.assertTrue(module.weight.grad is None      )







class _lowerCamelCase	(						lowercase__							):



		'''simple docstring'''







		A_     :      Tuple				   =    """gpt2-xl"""
		A_     :      List[Any]				   =    3.3191854854152187



'''simple docstring'''

def lowerCamelCase      (      lowerCAmelCase    :     int		):





	"""simple docstring"""







	if not isinstance(lowerCAmelCase		,		lowerCAmelCase		):
		__magic_name__	:   int					     =					f'Input value of [number={number}] must be an integer'
		raise TypeError(lowerCAmelCase		)
	if number < 0:
		return False
	__magic_name__	:   Tuple					     =					number * number
	while number > 0:
		if number % 10 != number_square % 10:
			return False
		number //= 10
		number_square //= 10
	return True


if __name__ == "__main__":
							import doctest

							doctest.testmod()