
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 					__magic_name__					(  __lowerCAmelCase      :		str				)     ->  int:
				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     ):






							def __init__(						self						:				List[str]				,     SCREAMING_SNAKE_CASE__						:				Union[str, Any]				,     SCREAMING_SNAKE_CASE__						:				List[str]    )	->				Any:
											super().__init__()
											__lowerCamelCase          =      module
											__lowerCamelCase          =      nn.Sequential(
											    nn.Linear(module.in_features				,     __a				,     bias=__a    )				,     nn.Linear(__a				,     module.out_features				,     bias=__a    )				,     )
											__lowerCamelCase          =      (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 					__A			(						self						:				Tuple				,     SCREAMING_SNAKE_CASE__						:				Any				,     *SCREAMING_SNAKE_CASE__						:				Any				,     **SCREAMING_SNAKE_CASE__						:				Optional[Any]    )	->				Tuple:
											return self.module(__a				,     *__a				,     **__a    ) + self.adapter(__a    )

@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class   lowerCAmelCase__	(      unittest.TestCase     ):
		a__			:		Optional[int]     =						"""bigscience/bloom-1b7"""

		# Constant values
		a__			:		Optional[Any]     =						2.109659552692574

		a__			:		str     =						"""Hello my name is"""
		a__			:		int     =						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__			:		Dict     =						10






		def 					__A			(						self						:				Dict    )	->				List[str]:
						# Models and tokenizer
						__lowerCamelCase          =      AutoTokenizer.from_pretrained(self.model_name    )





class   lowerCAmelCase__	(      a__     ):






		def 					__A			(						self						:				Optional[int]    )	->				int:
						super().setUp()

						# Models and tokenizer
						__lowerCamelCase          =      AutoModelForCausalLM.from_pretrained(
						    self.model_name				,     torch_dtype=torch.floataa				,     device_map='''auto'''    )
						__lowerCamelCase          =      AutoModelForCausalLM.from_pretrained(self.model_name				,     load_in_abit=__a				,     device_map='''auto'''    )






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

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






		def 					__A			(						self						:				Optional[int]    )	->				int:
						__lowerCamelCase          =      self.model_abit.config

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

						__lowerCamelCase          =      config.to_dict()
						__lowerCamelCase          =      config.to_diff_dict()

						__lowerCamelCase          =      config.to_json_string()






		def 					__A			(						self						:				Any    )	->				int:
						from bitsandbytes.nn import Paramsabit

						__lowerCamelCase          =      self.model_fpaa.get_memory_footprint()
						__lowerCamelCase          =      self.model_abit.get_memory_footprint()

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






		def 					__A			(						self						:				str    )	->				Dict:
						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 					__A			(						self						:				List[Any]    )	->				List[Any]:
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    )
						__lowerCamelCase          =      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 					__A			(						self						:				Any    )	->				List[Any]:
						__lowerCamelCase          =      BitsAndBytesConfig()
						__lowerCamelCase          =      True

						__lowerCamelCase          =      AutoModelForCausalLM.from_pretrained(
						    self.model_name				,     quantization_config=__a				,     device_map='''auto'''    )

						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    )
						__lowerCamelCase          =      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 					__A			(						self						:				Optional[int]    )	->				Tuple:
						with self.assertRaises(__a    ), tempfile.TemporaryDirectory() as tmpdirname:
										self.model_abit.save_pretrained(__a    )






		def 					__A			(						self						:				Dict    )	->				Tuple:
						__lowerCamelCase          =      BitsAndBytesConfig()

						with self.assertRaises(__a    ):
										__lowerCamelCase          =      AutoModelForCausalLM.from_pretrained(
										    self.model_name				,     quantization_config=__a				,     load_in_abit=__a				,     device_map='''auto'''				,     bnb_abit_quant_type='''nf4'''				,     )






		def 					__A			(						self						:				List[str]    )	->				Union[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
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    )

						__lowerCamelCase          =      self.model_fpaa.to(torch.floataa    )
						__lowerCamelCase          =      self.model_fpaa.generate(input_ids=encoded_input['''input_ids'''].to(0    )				,     max_new_tokens=10    )

						# Check this does not throw an error
						__lowerCamelCase          =      self.model_fpaa.to('''cpu'''    )

						# Check this does not throw an error
						__lowerCamelCase          =      self.model_fpaa.half()

						# Check this does not throw an error
						__lowerCamelCase          =      self.model_fpaa.float()







		def 					__A			(						self						:				Dict    )	->				Optional[int]:
						__lowerCamelCase          =      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     ):






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






		def 					__A			(						self						:				List[Any]    )	->				Any:
						gc.collect()
						torch.cuda.empty_cache()






		def 					__A			(						self						:				Union[str, Any]    )	->				List[Any]:
						from transformers import TaForConditionalGeneration

						__lowerCamelCase          =      TaForConditionalGeneration._keep_in_fpaa_modules
						__lowerCamelCase          =      None

						# test with `t5-small`
						__lowerCamelCase          =      TaForConditionalGeneration.from_pretrained(self.model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    ).to(0    )
						__lowerCamelCase          =      model.generate(**__a    )

						# test with `flan-t5-small`
						__lowerCamelCase          =      TaForConditionalGeneration.from_pretrained(
						    self.dense_act_model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    ).to(0    )
						__lowerCamelCase          =      model.generate(**__a    )
						__lowerCamelCase          =      modules







		def 					__A			(						self						:				int    )	->				Union[str, Any]:
						import bitsandbytes as bnb

						from transformers import TaForConditionalGeneration

						# test with `t5-small`
						__lowerCamelCase          =      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    )    )

						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    ).to(0    )
						__lowerCamelCase          =      model.generate(**__a    )

						# test with `flan-t5-small`
						__lowerCamelCase          =      TaForConditionalGeneration.from_pretrained(
						    self.dense_act_model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    ).to(0    )
						__lowerCamelCase          =      model.generate(**__a    )





class   lowerCAmelCase__	(      a__     ):






		def 					__A			(						self						:				Optional[int]    )	->				Optional[int]:
						super().setUp()
						# model_name
						__lowerCamelCase          =      """bigscience/bloom-560m"""
						__lowerCamelCase          =      """t5-small"""

						# Different types of model

						__lowerCamelCase          =      AutoModel.from_pretrained(self.model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						# Sequence classification model
						__lowerCamelCase          =      AutoModelForSequenceClassification.from_pretrained(
						    self.model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						# CausalLM model
						__lowerCamelCase          =      AutoModelForCausalLM.from_pretrained(self.model_name				,     load_in_abit=__a				,     device_map='''auto'''    )
						# Seq2seq model
						__lowerCamelCase          =      AutoModelForSeqaSeqLM.from_pretrained(
						    self.seq_to_seq_name				,     load_in_abit=__a				,     device_map='''auto'''    )






		def 					__A			(						self						:				Union[str, Any]    )	->				Optional[int]:
						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 					__A			(						self						:				int    )	->				str:
						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__	(      a__     ):






		def 					__A			(						self						:				Any    )	->				Tuple:
						super().setUp()






		def 					__A			(						self						:				Optional[int]    )	->				int:
						del self.pipe

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







		def 					__A			(						self						:				Any    )	->				str:
						__lowerCamelCase          =      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
						__lowerCamelCase          =      self.pipe(self.input_text    )
						self.assertIn(pipeline_output[0]['''generated_text''']				,     self.EXPECTED_OUTPUTS    )





@require_torch_multi_gpu
class   lowerCAmelCase__	(      a__     ):






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







		def 					__A			(						self						:				int    )	->				str:
						__lowerCamelCase          =      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
						__lowerCamelCase          =      self.tokenizer(self.input_text				,     return_tensors='''pt'''    )

						# Second real batch
						__lowerCamelCase          =      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__	(      a__     ):






		def 					__A			(						self						:				List[Any]    )	->				Optional[Any]:
						__lowerCamelCase          =      """facebook/opt-350m"""
						super().setUp()







		def 					__A			(						self						:				Dict    )	->				str:
						if version.parse(importlib.metadata.version('''bitsandbytes'''    )    ) < version.parse('''0.37.0'''    ):
										return

						# Step 1: freeze all parameters
						__lowerCamelCase          =      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():
										__lowerCamelCase          =      False  # freeze the model - train adapters later
										if param.ndim == 1:
														# cast the small parameters (e.g. layernorm) to fp32 for stability
														__lowerCamelCase          =      param.data.to(torch.floataa    )

        # Step 2: add adapters
						for _, module in model.named_modules():
										if "OPTAttention" in repr(type(__a    )    ):
														__lowerCamelCase          =      LoRALayer(module.q_proj				,     rank=16    )
														__lowerCamelCase          =      LoRALayer(module.k_proj				,     rank=16    )
														__lowerCamelCase          =      LoRALayer(module.v_proj				,     rank=16    )

        # Step 3: dummy batch
						__lowerCamelCase          =      self.tokenizer('''Test batch '''				,     return_tensors='''pt'''    ).to(0    )

						# Step 4: Check if the gradient is not None
						with torch.cuda.amp.autocast():
										__lowerCamelCase          =      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__	(      a__     ):
		a__			:		int     =						"""gpt2-xl"""
		a__			:		Dict     =						3.3191854854152187









'''simple docstring'''







import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
lowercase      :   List[str]      =       """."""


if __name__ == "__main__":
      lowercase      :   List[str]      =       os.path.join(REPO_PATH, """utils/documentation_tests.txt""")
      lowercase      :   Union[str, Any]      =       []
      lowercase      :   List[str]      =       []
      with open(doctest_file_path) as fp:
            for line in fp:
                  lowercase      :   List[str]      =       line.strip()
                  lowercase      :   Optional[Any]      =       os.path.join(REPO_PATH, line)
                  if not (os.path.isfile(path) or os.path.isdir(path)):
                        non_existent_paths.append(line)
                  all_paths.append(path)
      if len(non_existent_paths) > 0:
            lowercase      :   int      =       """\n""".join(non_existent_paths)
            raise ValueError(F"""`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}""")
      if all_paths != sorted(all_paths):
            raise ValueError("""Files in `utils/documentation_tests.txt` are not in alphabetical order.""")



