






"""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 						_SCREAMING_SNAKE_CASE (    __snake_case			:  Tuple    ):





  '''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							,		_lowerCamelCase							,		_lowerCamelCase       ):
          super().__init__()
          lowercase							    =       module
          lowercase							    =       nn.Sequential(
              nn.Linear(module.in_features							,		_lowerCamelCase							,		bias=_lowerCamelCase       )							,		nn.Linear(_lowerCamelCase							,		module.out_features							,		bias=_lowerCamelCase       )							,		)
          lowercase							    =       (2.0 / (5 * min(module.in_features							,		module.out_features       ))) ** 0.5
          nn.init.normal_(self.adapter[0].weight							,		std=_lowerCamelCase       )
          nn.init.zeros_(self.adapter[1].weight       )
          self.adapter.to(module.weight.device       )







        def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		*_lowerCamelCase							,		**_lowerCamelCase       ):
          return self.module(_lowerCamelCase							,		*_lowerCamelCase							,		**_lowerCamelCase       ) + self.adapter(_lowerCamelCase       )

@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
    UpperCAmelCase_ :     Optional[int]	     ="bigscience/bloom-1b7"

    # Constant values
    UpperCAmelCase_ :     Optional[Any]	     =2.1_09_65_95_52_69_25_74

    UpperCAmelCase_ :     List[Any]	     ="Hello my name is"
    UpperCAmelCase_ :     List[Any]	     =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_ :     Any	     =10







    def 			UpperCamelCase_      (			self       ):
      # Models and tokenizer
      lowercase							    =       AutoTokenizer.from_pretrained(self.model_name       )


class        a     (   a_	):







    def 			UpperCamelCase_      (			self       ):
      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=_lowerCamelCase							,		device_map='auto'       )







    def 			UpperCamelCase_      (			self       ):
      del self.model_fpaa
      del self.model_abit

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







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.model_abit.config

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

      lowercase							    =       config.to_dict()
      lowercase							    =       config.to_diff_dict()

      lowercase							    =       config.to_json_string()







    def 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      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(_lowerCamelCase							,		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 			UpperCamelCase_      (			self       ):
      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=1_0       )

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







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       BitsAndBytesConfig()
      lowercase							    =       True

      lowercase							    =       AutoModelForCausalLM.from_pretrained(
          self.model_name							,		quantization_config=_lowerCamelCase							,		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=1_0       )

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







    def 			UpperCamelCase_      (			self       ):
      with self.assertRaises(_lowerCamelCase       ), tempfile.TemporaryDirectory() as tmpdirname:
        self.model_abit.save_pretrained(_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       BitsAndBytesConfig()

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







    def 			UpperCamelCase_      (			self       ):
      with self.assertRaises(_lowerCamelCase       ):
        # Tries with `str`
        self.model_abit.to('cpu'       )

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

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

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

      with self.assertRaises(_lowerCamelCase       ):
        # 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=1_0       )

      # 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 			UpperCamelCase_      (			self       ):
      lowercase							    =       AutoModelForSeqaSeqLM.from_pretrained('t5-small'							,		load_in_abit=_lowerCamelCase							,		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 			UpperCamelCase_      (			cls       ):
      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 			UpperCamelCase_      (			self       ):
      gc.collect()
      torch.cuda.empty_cache()







    def 			UpperCamelCase_      (			self       ):
      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=_lowerCamelCase							,		device_map='auto'       )
      lowercase							    =       self.tokenizer(self.input_text							,		return_tensors='pt'       ).to(0       )
      lowercase							    =       model.generate(**_lowerCamelCase       )

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







    def 			UpperCamelCase_      (			self       ):
      import bitsandbytes as bnb

      from transformers import TaForConditionalGeneration

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

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


class        a     (   a_	):







    def 			UpperCamelCase_      (			self       ):
      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=_lowerCamelCase							,		device_map='auto'       )
      # Sequence classification model
      lowercase							    =       AutoModelForSequenceClassification.from_pretrained(
          self.model_name							,		load_in_abit=_lowerCamelCase							,		device_map='auto'       )
      # CausalLM model
      lowercase							    =       AutoModelForCausalLM.from_pretrained(self.model_name							,		load_in_abit=_lowerCamelCase							,		device_map='auto'       )
      # Seq2seq model
      lowercase							    =       AutoModelForSeqaSeqLM.from_pretrained(
          self.seq_to_seq_name							,		load_in_abit=_lowerCamelCase							,		device_map='auto'       )







    def 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      super().setUp()







    def 			UpperCamelCase_      (			self       ):
      del self.pipe

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







    def 			UpperCamelCase_      (			self       ):
      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 			UpperCamelCase_      (			self       ):
      super().setUp()







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       AutoModelForCausalLM.from_pretrained(
          self.model_name							,		load_in_abit=_lowerCamelCase							,		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=1_0       )
      self.assertIn(self.tokenizer.decode(output_parallel[0]							,		skip_special_tokens=_lowerCamelCase       )							,		self.EXPECTED_OUTPUTS       )


class        a     (   a_	):







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       'facebook/opt-350m'
      super().setUp()







    def 			UpperCamelCase_      (			self       ):
      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=_lowerCamelCase       )

      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(_lowerCamelCase       )       ):
          lowercase							    =       LoRALayer(module.q_proj							,		rank=1_6       )
          lowercase							    =       LoRALayer(module.k_proj							,		rank=1_6       )
          lowercase							    =       LoRALayer(module.v_proj							,		rank=1_6       )

        # 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(**_lowerCamelCase       )
        out.logits.norm().backward()

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


class        a     (   a_	):
    UpperCAmelCase_ :     Optional[Any]	     ="gpt2-xl"
    UpperCAmelCase_ :     Any	     =3.31_91_85_48_54_15_21_87










"""simple docstring"""



import requests
from bsa import BeautifulSoup
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  str = "AAPL"    ):





  '''simple docstring'''





  lowercase							    =       f'https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'
  lowercase							    =       BeautifulSoup(requests.get(__snake_case    ).text		,					'html.parser'    )
  lowercase							    =       'My(6px) Pos(r) smartphone_Mt(6px)'
  return soup.find('div'		,					class_=class_    ).find('span'    ).text


if __name__ == "__main__":
    for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
        print(F'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')


