






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   SCREAMING_SNAKE_CASE       (				snake_case_      :							Optional[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 							SCREAMING_SNAKE_CASE__		(       nn.Module		):





						"""simple docstring"""






						def __init__(      self  :						Any							,	__A  :						nn.Module							,	__A  :						int ):
							super().__init__()
							snake_case__				:   Optional[int]     =						module
							snake_case__				:   int     =						nn.Sequential(
							    nn.Linear(module.in_features							,	__A							,	bias=__A )							,	nn.Linear(__A							,	module.out_features							,	bias=__A )							,	)
							snake_case__				:   int     =						(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  _lowercase  (      self  :						Optional[Any]							,	__A  :						int							,	*__A  :						Optional[int]							,	**__A  :						Optional[Any] ):
							return self.module(__A							,	*__A							,	**__A ) + self.adapter(__A )



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





					"""simple docstring"""






					a_			=	"bigscience/bloom-1b7"

					# Constant values
					a_			=	2.109_6595_5269_2574

					a_			=	"Hello my name is"
					a_			=	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_			=	1_0



					def  _lowercase  (      self  :						Any ):
						# Models and tokenizer
						snake_case__				:   List[str]     =						AutoTokenizer.from_pretrained(self.model_name )



class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Union[str, Any] ):
						super().setUp()

						# Models and tokenizer
						snake_case__				:   Optional[int]     =						AutoModelForCausalLM.from_pretrained(
						    self.model_name							,	torch_dtype=torch.floataa							,	device_map="auto" )
						snake_case__				:   int     =						AutoModelForCausalLM.from_pretrained(self.model_name							,	load_in_abit=__A							,	device_map="auto" )



					def  _lowercase  (      self  :						Any ):
						del self.model_fpaa
						del self.model_abit

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



					def  _lowercase  (      self  :						Optional[int] ):
						snake_case__				:   List[str]     =						self.model_abit.config

						self.assertTrue(hasattr(__A							,	"quantization_config" ) )

						snake_case__				:   Optional[int]     =						config.to_dict()
						snake_case__				:   List[Any]     =						config.to_diff_dict()

						snake_case__				:   Optional[int]     =						config.to_json_string()



					def  _lowercase  (      self  :						Optional[Any] ):
						from bitsandbytes.nn import Paramsabit

						snake_case__				:   Tuple     =						self.model_fpaa.get_memory_footprint()
						snake_case__				:   Dict     =						self.model_abit.get_memory_footprint()

						self.assertAlmostEqual(mem_fpaa / mem_abit							,	self.EXPECTED_RELATIVE_DIFFERENCE )
						snake_case__				:   Optional[Any]     =						get_some_linear_layer(self.model_abit )
						self.assertTrue(linear.weight.__class__ == Paramsabit )



					def  _lowercase  (      self  :						List[str] ):
						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  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Optional[int]     =						self.tokenizer(self.input_text							,	return_tensors="pt" )
						snake_case__				:   Optional[int]     =						self.model_abit.generate(input_ids=encoded_input["input_ids"].to(0 )							,	max_new_tokens=1_0 )

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



					def  _lowercase  (      self  :						Optional[int] ):
						snake_case__				:   Tuple     =						BitsAndBytesConfig()
						snake_case__				:   str     =						True

						snake_case__				:   Any     =						AutoModelForCausalLM.from_pretrained(
						    self.model_name							,	quantization_config=__A							,	device_map="auto" )

						snake_case__				:   Optional[int]     =						self.tokenizer(self.input_text							,	return_tensors="pt" )
						snake_case__				:   List[str]     =						model_abit_from_config.generate(
						    input_ids=encoded_input["input_ids"].to(0 )							,	max_new_tokens=1_0 )

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



					def  _lowercase  (      self  :						List[Any] ):
						with self.assertRaises(__A ), tempfile.TemporaryDirectory() as tmpdirname:
							self.model_abit.save_pretrained(__A )



					def  _lowercase  (      self  :						Optional[Any] ):
						snake_case__				:   Optional[Any]     =						BitsAndBytesConfig()

						with self.assertRaises(__A ):
							snake_case__				:   Optional[int]     =						AutoModelForCausalLM.from_pretrained(
							    self.model_name							,	quantization_config=__A							,	load_in_abit=__A							,	device_map="auto"							,	bnb_abit_quant_type="nf4"							,	)



					def  _lowercase  (      self  :						int ):
						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
						snake_case__				:   List[str]     =						self.tokenizer(self.input_text							,	return_tensors="pt" )

						snake_case__				:   Optional[int]     =						self.model_fpaa.to(torch.floataa )
						snake_case__				:   Union[str, Any]     =						self.model_fpaa.generate(input_ids=encoded_input["input_ids"].to(0 )							,	max_new_tokens=1_0 )

						# Check this does not throw an error
						snake_case__				:   Union[str, Any]     =						self.model_fpaa.to("cpu" )

						# Check this does not throw an error
						snake_case__				:   Union[str, Any]     =						self.model_fpaa.half()

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






					def  _lowercase  (      self  :						Optional[Any] ):
						snake_case__				:   Dict     =						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 							SCREAMING_SNAKE_CASE__		(       unittest.TestCase		):





					"""simple docstring"""






					@classmethod
					def  _lowercase  (      cls  :						Dict ):
						snake_case__				:   Optional[int]     =						"t5-small"
						snake_case__				:   Tuple     =						"google/flan-t5-small"  # flan-t5 uses dense-act instead of dense-relu-dense
						snake_case__				:   List[Any]     =						AutoTokenizer.from_pretrained(cls.model_name )
						snake_case__				:   Optional[Any]     =						"Translate in German: Hello, my dog is cute"



					def  _lowercase  (      self  :						int ):
						gc.collect()
						torch.cuda.empty_cache()



					def  _lowercase  (      self  :						Optional[Any] ):
						from transformers import TaForConditionalGeneration

						snake_case__				:   Tuple     =						TaForConditionalGeneration._keep_in_fpaa_modules
						snake_case__				:   Dict     =						None

						# test with `t5-small`
						snake_case__				:   Any     =						TaForConditionalGeneration.from_pretrained(self.model_name							,	load_in_abit=__A							,	device_map="auto" )
						snake_case__				:   List[str]     =						self.tokenizer(self.input_text							,	return_tensors="pt" ).to(0 )
						snake_case__				:   Any     =						model.generate(**__A )

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






					def  _lowercase  (      self  :						str ):
						import bitsandbytes as bnb

						from transformers import TaForConditionalGeneration

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

						snake_case__				:   Tuple     =						self.tokenizer(self.input_text							,	return_tensors="pt" ).to(0 )
						snake_case__				:   str     =						model.generate(**__A )

						# test with `flan-t5-small`
						snake_case__				:   Optional[Any]     =						TaForConditionalGeneration.from_pretrained(
						    self.dense_act_model_name							,	load_in_abit=__A							,	device_map="auto" )
						snake_case__				:   str     =						self.tokenizer(self.input_text							,	return_tensors="pt" ).to(0 )
						snake_case__				:   List[Any]     =						model.generate(**__A )



class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Any ):
						super().setUp()
						# model_name
						snake_case__				:   Union[str, Any]     =						"bigscience/bloom-560m"
						snake_case__				:   int     =						"t5-small"

						# Different types of model

						snake_case__				:   List[Any]     =						AutoModel.from_pretrained(self.model_name							,	load_in_abit=__A							,	device_map="auto" )
						# Sequence classification model
						snake_case__				:   Dict     =						AutoModelForSequenceClassification.from_pretrained(
						    self.model_name							,	load_in_abit=__A							,	device_map="auto" )
						# CausalLM model
						snake_case__				:   List[Any]     =						AutoModelForCausalLM.from_pretrained(self.model_name							,	load_in_abit=__A							,	device_map="auto" )
						# Seq2seq model
						snake_case__				:   Union[str, Any]     =						AutoModelForSeqaSeqLM.from_pretrained(
						    self.seq_to_seq_name							,	load_in_abit=__A							,	device_map="auto" )



					def  _lowercase  (      self  :						Any ):
						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  _lowercase  (      self  :						Any ):
						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 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Dict ):
						super().setUp()



					def  _lowercase  (      self  :						Union[str, Any] ):
						del self.pipe

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






					def  _lowercase  (      self  :						str ):
						snake_case__				:   List[Any]     =						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
						snake_case__				:   List[Any]     =						self.pipe(self.input_text )
						self.assertIn(pipeline_output[0]["generated_text"]							,	self.EXPECTED_OUTPUTS )



@require_torch_multi_gpu
class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					def  _lowercase  (      self  :						int ):
						super().setUp()






					def  _lowercase  (      self  :						Union[str, Any] ):
						snake_case__				:   Dict     =						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
						snake_case__				:   Union[str, Any]     =						self.tokenizer(self.input_text							,	return_tensors="pt" )

						# Second real batch
						snake_case__				:   Optional[Any]     =						model_parallel.generate(input_ids=encoded_input["input_ids"].to(0 )							,	max_new_tokens=1_0 )
						self.assertIn(self.tokenizer.decode(output_parallel[0]							,	skip_special_tokens=__A )							,	self.EXPECTED_OUTPUTS )



class 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					def  _lowercase  (      self  :						Optional[int] ):
						snake_case__				:   Optional[Any]     =						"facebook/opt-350m"
						super().setUp()






					def  _lowercase  (      self  :						Dict ):
						if version.parse(importlib.metadata.version("bitsandbytes" ) ) < version.parse("0.37.0" ):
							return

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

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

        # Step 3: dummy batch
						snake_case__				:   Any     =						self.tokenizer("Test batch "							,	return_tensors="pt" ).to(0 )

						# Step 4: Check if the gradient is not None
						with torch.cuda.amp.autocast():
							snake_case__				:   Optional[int]     =						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 							SCREAMING_SNAKE_CASE__		(       UpperCamelCase_		):





					"""simple docstring"""






					a_			=	"gpt2-xl"
					a_			=	3.3191_8548_5415_2187











import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier







def   SCREAMING_SNAKE_CASE       (				snake_case_      :							dict     ):
	return (data["data"], data["target"])







def   SCREAMING_SNAKE_CASE       (				snake_case_      :							np.ndarray  ,						snake_case_      :							np.ndarray     ):
	snake_case__				:   Optional[int]     =						XGBClassifier()
	classifier.fit(snake_case_  ,						snake_case_     )
	return classifier







def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Any     =						load_iris()
	snake_case__,		snake_case__				:   str     =						data_handling(snake_case_     )
	snake_case__,		snake_case__,		snake_case__,		snake_case__				:   int     =						train_test_split(
	    snake_case_  ,						snake_case_  ,						test_size=0.25     )

	snake_case__				:   Dict     =						iris["target_names"]

	# Create an XGBoost Classifier from the training data
	snake_case__				:   Dict     =						xgboost(snake_case_  ,						snake_case_     )

	# Display the confusion matrix of the classifier with both training and test sets
	ConfusionMatrixDisplay.from_estimator(
	    snake_case_  ,						snake_case_  ,						snake_case_  ,						display_labels=snake_case_  ,						cmap="Blues"  ,						normalize="true"  ,						)
	plt.title("Normalized Confusion Matrix - IRIS Dataset"     )
	plt.show()


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()



