"""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 					__a   (		A      ):






     '''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    a__    (   nn.Module	):


    def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase  ):
         '''simple docstring'''



         super().__init__()
         lowercase__				 =							module
         lowercase__				 =							nn.Sequential(
             nn.Linear(module.in_features,				_UpperCAmelCase,				bias=_UpperCAmelCase  ),				nn.Linear(_UpperCAmelCase,				module.out_features,				bias=_UpperCAmelCase  ),				)
         lowercase__				 =							(2.0 / (5 * min(module.in_features,				module.out_features  ))) ** 0.5
         nn.init.normal_(self.adapter[0].weight,				std=_UpperCAmelCase  )
         nn.init.zeros_(self.adapter[1].weight  )
         self.adapter.to(module.weight.device  )


    def 	snake_case__	(     self,				_UpperCAmelCase,				*_UpperCAmelCase,				**_UpperCAmelCase  ):
         '''simple docstring'''



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






@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class    a__    (   unittest.TestCase	):
   # We keep the constants inside the init function and model loading inside setUp function

   # We need to test on relatively large models (aka >1b parameters otherwise the quantiztion may not work as expected)
   # Therefore here we use only bloom-1b3 to test our module
   snake_case_							=      "bigscience/bloom-1b7"

   # Constant values
   snake_case_							=      2.109659552692574

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							AutoTokenizer.from_pretrained(self.model_name  )






class    a__    (   _a	):


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        super().setUp()

        # Models and tokenizer
        lowercase__				 =							AutoModelForCausalLM.from_pretrained(
            self.model_name,				torch_dtype=torch.floataa,				device_map="auto"  )
        lowercase__				 =							AutoModelForCausalLM.from_pretrained(self.model_name,				load_in_abit=_UpperCAmelCase,				device_map="auto"  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        del self.model_fpaa
        del self.model_abit

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_abit.config

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

        lowercase__				 =							config.to_dict()
        lowercase__				 =							config.to_diff_dict()

        lowercase__				 =							config.to_json_string()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        from bitsandbytes.nn import Paramsabit

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

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


   def 	snake_case__	(     self  ):
        '''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(_UpperCAmelCase,				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 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.tokenizer(self.input_text,				return_tensors="pt"  )
        lowercase__				 =							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=_UpperCAmelCase  ),				self.EXPECTED_OUTPUTS  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							BitsAndBytesConfig()
        lowercase__				 =							True

        lowercase__				 =							AutoModelForCausalLM.from_pretrained(
            self.model_name,				quantization_config=_UpperCAmelCase,				device_map="auto"  )

        lowercase__				 =							self.tokenizer(self.input_text,				return_tensors="pt"  )
        lowercase__				 =							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=_UpperCAmelCase  ),				self.EXPECTED_OUTPUTS  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							BitsAndBytesConfig()

        with self.assertRaises(_UpperCAmelCase  ):
             lowercase__				 =							AutoModelForCausalLM.from_pretrained(
                 self.model_name,				quantization_config=_UpperCAmelCase,				load_in_abit=_UpperCAmelCase,				device_map="auto",				bnb_abit_quant_type="nf4",				)


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        with self.assertRaises(_UpperCAmelCase  ):
             # Tries with `str`
             self.model_abit.to("cpu"  )

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

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

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

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

        # Test if we did not break anything
        lowercase__				 =							self.tokenizer(self.input_text,				return_tensors="pt"  )

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

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

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

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							AutoModelForSeqaSeqLM.from_pretrained("t5-small",				load_in_abit=_UpperCAmelCase,				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    a__    (   unittest.TestCase	):


   @classmethod
   def 	snake_case__	(     cls  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        from transformers import TaForConditionalGeneration

        lowercase__				 =							TaForConditionalGeneration._keep_in_fpaa_modules
        lowercase__				 =							None

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

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        import bitsandbytes as bnb

        from transformers import TaForConditionalGeneration

        # test with `t5-small`
        lowercase__				 =							TaForConditionalGeneration.from_pretrained(self.model_name,				load_in_abit=_UpperCAmelCase,				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  )  )

        lowercase__				 =							self.tokenizer(self.input_text,				return_tensors="pt"  ).to(0  )
        lowercase__				 =							model.generate(**_UpperCAmelCase  )

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






class    a__    (   _a	):


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        super().setUp()
        # model_name
        lowercase__				 =							"bigscience/bloom-560m"
        lowercase__				 =							"t5-small"

        # Different types of model

        lowercase__				 =							AutoModel.from_pretrained(self.model_name,				load_in_abit=_UpperCAmelCase,				device_map="auto"  )
        # Sequence classification model
        lowercase__				 =							AutoModelForSequenceClassification.from_pretrained(
            self.model_name,				load_in_abit=_UpperCAmelCase,				device_map="auto"  )
        # CausalLM model
        lowercase__				 =							AutoModelForCausalLM.from_pretrained(self.model_name,				load_in_abit=_UpperCAmelCase,				device_map="auto"  )
        # Seq2seq model
        lowercase__				 =							AutoModelForSeqaSeqLM.from_pretrained(
            self.seq_to_seq_name,				load_in_abit=_UpperCAmelCase,				device_map="auto"  )


   def 	snake_case__	(     self  ):
        '''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 	snake_case__	(     self  ):
        '''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    a__    (   _a	):


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        super().setUp()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        del self.pipe

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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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






@require_torch_multi_gpu
class    a__    (   _a	):


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        super().setUp()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							AutoModelForCausalLM.from_pretrained(
            self.model_name,				load_in_abit=_UpperCAmelCase,				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
        lowercase__				 =							self.tokenizer(self.input_text,				return_tensors="pt"  )

        # Second real batch
        lowercase__				 =							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=_UpperCAmelCase  ),				self.EXPECTED_OUTPUTS  )






class    a__    (   _a	):


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							"facebook/opt-350m"
        super().setUp()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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

        # Step 1: freeze all parameters
        lowercase__				 =							AutoModelForCausalLM.from_pretrained(self.model_name,				load_in_abit=_UpperCAmelCase  )

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

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

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

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

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

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






class    a__    (   _a	):
   snake_case_							=      "gpt2-xl"
   snake_case_							=      3.3191854854152187





"""simple docstring"""


from __future__ import annotations

import math







def 					__a   (		A      ):






     '''simple docstring'''



     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5    ,				int(math.sqrt(A      ) + 1      )    ,				6      ):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True


lowerCAmelCase_:					Optional[Any]     =					[num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]







def 					__a   (		A      ):






     '''simple docstring'''



     if not isinstance(A    ,				A      ):
          raise ValueError("n must be an integer"      )
     if n <= 0:
          raise ValueError("n must be >= 0"      )

     lowercase__				 =							[]
     for num in range(len(A      )      ):
          lowercase__				 =							0
          while 2 * i * i <= odd_composites[num]:
               lowercase__				 =							odd_composites[num] - 2 * i * i
               if is_prime(A      ):
                    break
               i += 1
          else:
               list_nums.append(odd_composites[num]      )
               if len(A      ) == n:
                    return list_nums

     return []







def 					__a   (		):






     '''simple docstring'''



     return compute_nums(1      )[0]


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




