

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   __UpperCAmelCase					(      __a :     Any      )     ->	Optional[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 							UpperCAmelCase_						(     nn.Module  ):
										"""simple docstring"""







										def __init__(     self			,				_a			,				_a			)       ->       int:
															super().__init__()
															_a      :       List[Any]   =						module
															_a      :       Optional[Any]   =						nn.Sequential(
															    nn.Linear(module.in_features			,				__lowercase			,				bias=__lowercase			)			,				nn.Linear(__lowercase			,				module.out_features			,				bias=__lowercase			)			,				)
															_a      :       List[Any]   =						(2.0 / (5 * min(module.in_features			,				module.out_features			))) ** 0.5
															nn.init.normal_(self.adapter[0].weight			,				std=__lowercase			)
															nn.init.zeros_(self.adapter[1].weight			)
															self.adapter.to(module.weight.device			)




										def 							__lowercase							(     self			,				_a			,				*_a			,				**_a			)       ->       int:
															return self.module(__lowercase			,				*__lowercase			,				**__lowercase			) + self.adapter(__lowercase			)

@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class 							UpperCAmelCase_						(     unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Optional[Any]             =       "bigscience/bloom-1b7"

							# Constant values
							UpperCAmelCase__			:		str             =       2.109659552692574

							UpperCAmelCase__			:		Union[str, Any]             =       "Hello my name is"
							UpperCAmelCase__			:		List[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"  )
							UpperCAmelCase__			:		Optional[Any]             =       10


							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       Union[str, Any]   =						AutoTokenizer.from_pretrained(self.model_name			)



class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







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

												# Models and tokenizer
												_a      :       Optional[Any]   =						AutoModelForCausalLM.from_pretrained(
												    self.model_name			,				torch_dtype=torch.floataa			,				device_map='''auto'''			)
												_a      :       str   =						AutoModelForCausalLM.from_pretrained(self.model_name			,				load_in_abit=__lowercase			,				device_map='''auto'''			)


							def 							__lowercase							(     self			)       ->       Any:
												del self.model_fpaa
												del self.model_abit

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


							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												_a      :       List[str]   =						self.model_abit.config

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

												_a      :       Optional[int]   =						config.to_dict()
												_a      :       Tuple   =						config.to_diff_dict()

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


							def 							__lowercase							(     self			)       ->       Dict:
												from bitsandbytes.nn import Paramsabit

												_a      :       List[str]   =						self.model_fpaa.get_memory_footprint()
												_a      :       List[str]   =						self.model_abit.get_memory_footprint()

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


							def 							__lowercase							(     self			)       ->       Optional[int]:
												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(__lowercase			,				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			)       ->       str:
												_a      :       Optional[int]   =						self.tokenizer(self.input_text			,				return_tensors='''pt'''			)
												_a      :       Optional[Any]   =						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=__lowercase			)			,				self.EXPECTED_OUTPUTS			)


							def 							__lowercase							(     self			)       ->       Tuple:
												_a      :       Dict   =						BitsAndBytesConfig()
												_a      :       Dict   =						True

												_a      :       Any   =						AutoModelForCausalLM.from_pretrained(
												    self.model_name			,				quantization_config=__lowercase			,				device_map='''auto'''			)

												_a      :       List[str]   =						self.tokenizer(self.input_text			,				return_tensors='''pt'''			)
												_a      :       Any   =						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=__lowercase			)			,				self.EXPECTED_OUTPUTS			)


							def 							__lowercase							(     self			)       ->       Tuple:







												with self.assertRaises(__lowercase			), tempfile.TemporaryDirectory() as tmpdirname:
																	self.model_abit.save_pretrained(__lowercase			)


							def 							__lowercase							(     self			)       ->       Any:
												_a      :       List[Any]   =						BitsAndBytesConfig()

												with self.assertRaises(__lowercase			):
																	_a      :       Any   =						AutoModelForCausalLM.from_pretrained(
																	    self.model_name			,				quantization_config=__lowercase			,				load_in_abit=__lowercase			,				device_map='''auto'''			,				bnb_abit_quant_type='''nf4'''			,				)


							def 							__lowercase							(     self			)       ->       str:







												with self.assertRaises(__lowercase			):
																	# Tries with `str`
																	self.model_abit.to('''cpu'''			)

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

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

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

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

												# Test if we did not break anything
												_a      :       Union[str, Any]   =						self.tokenizer(self.input_text			,				return_tensors='''pt'''			)

												_a      :       Optional[int]   =						self.model_fpaa.to(torch.floataa			)
												_a      :       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
												_a      :       List[Any]   =						self.model_fpaa.to('''cpu'''			)

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

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




							def 							__lowercase							(     self			)       ->       int:
												_a      :       Optional[Any]   =						AutoModelForSeqaSeqLM.from_pretrained('''t5-small'''			,				load_in_abit=__lowercase			,				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 							UpperCAmelCase_						(     unittest.TestCase  ):
							"""simple docstring"""







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


							def 							__lowercase							(     self			)       ->       Dict:
												gc.collect()
												torch.cuda.empty_cache()


							def 							__lowercase							(     self			)       ->       Any:
												from transformers import TaForConditionalGeneration

												_a      :       Dict   =						TaForConditionalGeneration._keep_in_fpaa_modules
												_a      :       Any   =						None

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

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




							def 							__lowercase							(     self			)       ->       Dict:
												import bitsandbytes as bnb

												from transformers import TaForConditionalGeneration

												# test with `t5-small`
												_a      :       Optional[int]   =						TaForConditionalGeneration.from_pretrained(self.model_name			,				load_in_abit=__lowercase			,				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			)			)

												_a      :       Optional[int]   =						self.tokenizer(self.input_text			,				return_tensors='''pt'''			).to(0			)
												_a      :       Optional[Any]   =						model.generate(**__lowercase			)

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



class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







							def 							__lowercase							(     self			)       ->       List[Any]:
												super().setUp()
												# model_name
												_a      :       Optional[int]   =						'''bigscience/bloom-560m'''
												_a      :       int   =						'''t5-small'''

												# Different types of model

												_a      :       Any   =						AutoModel.from_pretrained(self.model_name			,				load_in_abit=__lowercase			,				device_map='''auto'''			)
												# Sequence classification model
												_a      :       Optional[int]   =						AutoModelForSequenceClassification.from_pretrained(
												    self.model_name			,				load_in_abit=__lowercase			,				device_map='''auto'''			)
												# CausalLM model
												_a      :       Dict   =						AutoModelForCausalLM.from_pretrained(self.model_name			,				load_in_abit=__lowercase			,				device_map='''auto'''			)
												# Seq2seq model
												_a      :       Union[str, Any]   =						AutoModelForSeqaSeqLM.from_pretrained(
												    self.seq_to_seq_name			,				load_in_abit=__lowercase			,				device_map='''auto'''			)


							def 							__lowercase							(     self			)       ->       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 							__lowercase							(     self			)       ->       Union[str, 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 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







							def 							__lowercase							(     self			)       ->       Optional[Any]:
												super().setUp()


							def 							__lowercase							(     self			)       ->       Optional[Any]:
												del self.pipe

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




							def 							__lowercase							(     self			)       ->       Optional[int]:
												_a      :       Optional[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
												_a      :       Optional[Any]   =						self.pipe(self.input_text			)
												self.assertIn(pipeline_output[0]['''generated_text''']			,				self.EXPECTED_OUTPUTS			)



@require_torch_multi_gpu
class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







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




							def 							__lowercase							(     self			)       ->       List[str]:
												_a      :       Tuple   =						AutoModelForCausalLM.from_pretrained(
												    self.model_name			,				load_in_abit=__lowercase			,				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
												_a      :       str   =						self.tokenizer(self.input_text			,				return_tensors='''pt'''			)

												# Second real batch
												_a      :       Optional[int]   =						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=__lowercase			)			,				self.EXPECTED_OUTPUTS			)



class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







							def 							__lowercase							(     self			)       ->       str:
												_a      :       Tuple   =						'''facebook/opt-350m'''
												super().setUp()




							def 							__lowercase							(     self			)       ->       Any:







												if version.parse(importlib.metadata.version('''bitsandbytes'''			)			) < version.parse('''0.37.0'''			):
																	return

												# Step 1: freeze all parameters
												_a      :       Union[str, Any]   =						AutoModelForCausalLM.from_pretrained(self.model_name			,				load_in_abit=__lowercase			)

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

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

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

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

												# Step 4: Check if the gradient is not None
												with torch.cuda.amp.autocast():
																	_a      :       int   =						model.forward(**__lowercase			)
																	out.logits.norm().backward()

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



class 							UpperCAmelCase_						(     __lowercase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		str             =       "gpt2-xl"
							UpperCAmelCase__			:		Union[str, Any]             =       3.3191854854152187






'''simple docstring'''

import string

def 					__UpperCamelCase				(						lowercase__    :	str			):






     '''simple docstring'''





     for key in range(len(string.ascii_uppercase			)			):
          __lowercase      		=''
          for symbol in message:
               if symbol in string.ascii_uppercase:
                    __lowercase      		=string.ascii_uppercase.find(lowercase__			)
                    __lowercase      		=num - key
                    if num < 0:
                         __lowercase      		=num + len(string.ascii_uppercase			)
                    __lowercase      		=translated + string.ascii_uppercase[num]
               else:
                    __lowercase      		=translated + symbol
          print(F'''Decryption using Key #{key}: {translated}'''			)

def 					__UpperCamelCase				(						):






     '''simple docstring'''





     __lowercase      		=input('Encrypted message: '			)
     __lowercase      		=message.upper()
     decrypt(lowercase__			)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()


