





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   __snake_case    (       _lowerCAmelCase			:			int						)			->    Union[str, Any]:
   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        __magic_name__	(				nn.Module				):





      """simple docstring"""



      def __init__(				self							:Dict      ,   snake_case							:nn.Module      ,   snake_case							:int	):





         '''simple docstring'''




         super().__init__()
         A_       :					int        =      module
         A_       :					str        =      nn.Sequential(
             nn.Linear(module.in_features      ,   a_      ,   bias=a_	)      ,   nn.Linear(a_      ,   module.out_features      ,   bias=a_	)      ,   )
         A_       :					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     SCREAMING_SNAKE_CASE		(				self							:Tuple      ,   snake_case							:Optional[Any]      ,   *snake_case							:Optional[int]      ,   **snake_case							:List[str]	):





         '''simple docstring'''




         return self.module(a_      ,   *a_      ,   **a_	) + self.adapter(a_	)


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





     """simple docstring"""



     __UpperCamelCase            =  "bigscience/bloom-1b7"

     # Constant values
     __UpperCamelCase            =  2.109_6595_5269_2574

     __UpperCamelCase            =  "Hello my name is"
     __UpperCamelCase            =  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            =  10



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        A_       :					Dict        =      AutoTokenizer.from_pretrained(self.model_name	)




class        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        super().setUp()

        # Models and tokenizer
        A_       :					List[str]        =      AutoModelForCausalLM.from_pretrained(
            self.model_name      ,   torch_dtype=torch.floataa      ,   device_map="auto"	)
        A_       :					List[str]        =      AutoModelForCausalLM.from_pretrained(self.model_name      ,   load_in_abit=a_      ,   device_map="auto"	)



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        del self.model_fpaa
        del self.model_abit

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



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        A_       :					List[str]        =      self.model_abit.config

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

        A_       :					Optional[int]        =      config.to_dict()
        A_       :					Union[str, Any]        =      config.to_diff_dict()

        A_       :					int        =      config.to_json_string()



     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        from bitsandbytes.nn import Paramsabit

        A_       :					Tuple        =      self.model_fpaa.get_memory_footprint()
        A_       :					List[Any]        =      self.model_abit.get_memory_footprint()

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



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        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     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        A_       :					Optional[int]        =      self.tokenizer(self.input_text      ,   return_tensors="pt"	)
        A_       :					List[str]        =      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     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        A_       :					int        =      BitsAndBytesConfig()
        A_       :					Dict        =      True

        A_       :					Tuple        =      AutoModelForCausalLM.from_pretrained(
            self.model_name      ,   quantization_config=a_      ,   device_map="auto"	)

        A_       :					Tuple        =      self.tokenizer(self.input_text      ,   return_tensors="pt"	)
        A_       :					Union[str, Any]        =      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     SCREAMING_SNAKE_CASE		(				self							:int	):





        '''simple docstring'''




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



     def     SCREAMING_SNAKE_CASE		(				self							:List[Any]	):





        '''simple docstring'''




        A_       :					Dict        =      BitsAndBytesConfig()

        with self.assertRaises(a_	):
           A_       :					Tuple        =      AutoModelForCausalLM.from_pretrained(
               self.model_name      ,   quantization_config=a_      ,   load_in_abit=a_      ,   device_map="auto"      ,   bnb_abit_quant_type="nf4"      ,   )



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        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
        A_       :					Optional[int]        =      self.tokenizer(self.input_text      ,   return_tensors="pt"	)

        A_       :					Optional[int]        =      self.model_fpaa.to(torch.floataa	)
        A_       :					List[Any]        =      self.model_fpaa.generate(input_ids=encoded_input["input_ids"].to(0	)      ,   max_new_tokens=10	)

        # Check this does not throw an error
        A_       :					str        =      self.model_fpaa.to("cpu"	)

        # Check this does not throw an error
        A_       :					Any        =      self.model_fpaa.half()

        # Check this does not throw an error
        A_       :					Optional[Any]        =      self.model_fpaa.float()





     def     SCREAMING_SNAKE_CASE		(				self							:Dict	):





        '''simple docstring'''




        A_       :					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        __magic_name__	(				unittest.TestCase				):





     """simple docstring"""



     @classmethod
     def     SCREAMING_SNAKE_CASE		(				cls							:Optional[int]	):





        '''simple docstring'''




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



     def     SCREAMING_SNAKE_CASE		(				self							:int	):





        '''simple docstring'''




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



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        from transformers import TaForConditionalGeneration

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

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

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





     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        import bitsandbytes as bnb

        from transformers import TaForConditionalGeneration

        # test with `t5-small`
        A_       :					List[str]        =      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	)	)

        A_       :					List[str]        =      self.tokenizer(self.input_text      ,   return_tensors="pt"	).to(0	)
        A_       :					int        =      model.generate(**a_	)

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




class        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        super().setUp()
        # model_name
        A_       :					List[str]        =      "bigscience/bloom-560m"
        A_       :					Dict        =      "t5-small"

        # Different types of model

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



     def     SCREAMING_SNAKE_CASE		(				self							:Optional[Any]	):





        '''simple docstring'''




        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     SCREAMING_SNAKE_CASE		(				self							:List[str]	):





        '''simple docstring'''




        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        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:Tuple	):





        '''simple docstring'''




        super().setUp()



     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        del self.pipe

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





     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




        A_       :					str        =      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_       :					Tuple        =      self.pipe(self.input_text	)
        self.assertIn(pipeline_output[0]["generated_text"]      ,   self.EXPECTED_OUTPUTS	)




@require_torch_multi_gpu
class        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        super().setUp()





     def     SCREAMING_SNAKE_CASE		(				self							:Optional[int]	):





        '''simple docstring'''




        A_       :					Optional[Any]        =      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
        A_       :					Tuple        =      self.tokenizer(self.input_text      ,   return_tensors="pt"	)

        # Second real batch
        A_       :					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        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     def     SCREAMING_SNAKE_CASE		(				self							:str	):





        '''simple docstring'''




        A_       :					List[str]        =      "facebook/opt-350m"
        super().setUp()





     def     SCREAMING_SNAKE_CASE		(				self							:Union[str, Any]	):





        '''simple docstring'''




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

        # Step 1: freeze all parameters
        A_       :					int        =      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():
           A_       :					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(a_	)	):
              A_       :					Optional[Any]        =      LoRALayer(module.q_proj      ,   rank=16	)
              A_       :					Dict        =      LoRALayer(module.k_proj      ,   rank=16	)
              A_       :					str        =      LoRALayer(module.v_proj      ,   rank=16	)

        # Step 3: dummy batch
        A_       :					Optional[int]        =      self.tokenizer("Test batch "      ,   return_tensors="pt"	).to(0	)

        # Step 4: Check if the gradient is not None
        with torch.cuda.amp.autocast():
           A_       :					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        __magic_name__	(				_UpperCamelCase				):





     """simple docstring"""



     __UpperCamelCase            =  "gpt2-xl"
     __UpperCamelCase            =  3.3191_8548_5415_2187







"""simple docstring"""






from __future__ import annotations






def      lowercase__ (					lowerCAmelCase__   :			int			)    ->			list[int]:



			'''simple docstring'''
			a__  :	Tuple		 =			[True] * limit
			a__  :	Tuple		 =			False
			a__  :	int		 =			False
			a__  :	Tuple		 =			True

			for i in range(3							,			int(limit**0.5 + 1			)							,			2			):
						a__  :	int		 =			i * 2
						while index < limit:
									a__  :	Union[str, Any]		 =			False
									a__  :	int		 =			index + i

			a__  :	str		 =			[2]

			for i in range(3							,			lowerCAmelCase__							,			2			):
						if is_prime[i]:
									primes.append(lowerCAmelCase__			)

			return primes






def      lowercase__ (					lowerCAmelCase__   :			int = 1_0_0_0_0_0_0			)    ->			int:



			'''simple docstring'''
			a__  :	List[Any]		 =			prime_sieve(lowerCAmelCase__			)
			a__  :	int		 =			0
			a__  :	str		 =			0

			for i in range(len(lowerCAmelCase__			)			):
						for j in range(i + length							,			len(lowerCAmelCase__			)			):
									a__  :	List[str]		 =			sum(primes[i:j]			)
									if sol >= ceiling:
												break

									if sol in primes:
												a__  :	Tuple		 =			j - i
												a__  :	Union[str, Any]		 =			sol

			return largest


if __name__ == "__main__":
		print(f"{solution() = }")