





"""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			(_UpperCAmelCase					:    Tuple			):
 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				,       _snake_case				,       _snake_case     ):







         """simple docstring"""






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



        def    UpperCamelCase__  (     self				,       _snake_case				,       *_snake_case				,       **_snake_case     ):







         """simple docstring"""






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







@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.1_09_65_95_52_69_25_74

 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__             =       1_0



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= AutoTokenizer.from_pretrained(self.model_name     )







class       a							(   a__  ):



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  super().setUp()

  # Models and tokenizer
  lowerCAmelCase    				= AutoModelForCausalLM.from_pretrained(
      self.model_name				,       torch_dtype=torch.floataa				,       device_map='auto'     )
  lowerCAmelCase    				= AutoModelForCausalLM.from_pretrained(self.model_name				,       load_in_abit=_snake_case				,       device_map='auto'     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  del self.model_fpaa
  del self.model_abit

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= self.model_abit.config

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

  lowerCAmelCase    				= config.to_dict()
  lowerCAmelCase    				= config.to_diff_dict()

  lowerCAmelCase    				= config.to_json_string()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  from bitsandbytes.nn import Paramsabit

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

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



 def    UpperCamelCase__  (     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(_snake_case				,       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     ):







  """simple docstring"""






  lowerCAmelCase    				= self.tokenizer(self.input_text				,       return_tensors='pt'     )
  lowerCAmelCase    				= 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=_snake_case     )				,       self.EXPECTED_OUTPUTS     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= BitsAndBytesConfig()
  lowerCAmelCase    				= True

  lowerCAmelCase    				= AutoModelForCausalLM.from_pretrained(
      self.model_name				,       quantization_config=_snake_case				,       device_map='auto'     )

  lowerCAmelCase    				= self.tokenizer(self.input_text				,       return_tensors='pt'     )
  lowerCAmelCase    				= 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=_snake_case     )				,       self.EXPECTED_OUTPUTS     )



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= BitsAndBytesConfig()

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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

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

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

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

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

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

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

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

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

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= AutoModelForSeqaSeqLM.from_pretrained('t5-small'				,       load_in_abit=_snake_case				,       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     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  from transformers import TaForConditionalGeneration

  lowerCAmelCase    				= TaForConditionalGeneration._keep_in_fpaa_modules
  lowerCAmelCase    				= None

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

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  import bitsandbytes as bnb

  from transformers import TaForConditionalGeneration

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

  lowerCAmelCase    				= self.tokenizer(self.input_text				,       return_tensors='pt'     ).to(0     )
  lowerCAmelCase    				= model.generate(**_snake_case     )

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







class       a							(   a__  ):



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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

  # Different types of model

  lowerCAmelCase    				= AutoModel.from_pretrained(self.model_name				,       load_in_abit=_snake_case				,       device_map='auto'     )
  # Sequence classification model
  lowerCAmelCase    				= AutoModelForSequenceClassification.from_pretrained(
      self.model_name				,       load_in_abit=_snake_case				,       device_map='auto'     )
  # CausalLM model
  lowerCAmelCase    				= AutoModelForCausalLM.from_pretrained(self.model_name				,       load_in_abit=_snake_case				,       device_map='auto'     )
  # Seq2seq model
  lowerCAmelCase    				= AutoModelForSeqaSeqLM.from_pretrained(
      self.seq_to_seq_name				,       load_in_abit=_snake_case				,       device_map='auto'     )



 def    UpperCamelCase__  (     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    UpperCamelCase__  (     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    UpperCamelCase__  (     self     ):







  """simple docstring"""






  super().setUp()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  del self.pipe

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



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= 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
  lowerCAmelCase    				= 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     ):







  """simple docstring"""






  super().setUp()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= AutoModelForCausalLM.from_pretrained(
      self.model_name				,       load_in_abit=_snake_case				,       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
  lowerCAmelCase    				= self.tokenizer(self.input_text				,       return_tensors='pt'     )

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







class       a							(   a__  ):



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






  lowerCAmelCase    				= 'facebook/opt-350m'
  super().setUp()



 def    UpperCamelCase__  (     self     ):







  """simple docstring"""






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

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

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

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

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

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

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

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







class       a							(   a__  ):
 snake_case__             =       '''gpt2-xl'''
 snake_case__             =       3.31_91_85_48_54_15_21_87












"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCamelCase     :						List[str]						       =  logging.get_logger(__name__)

__UpperCamelCase     :						Tuple						       =  {
    '''vinvino02/glpn-kitti''': '''https://huggingface.co/vinvino02/glpn-kitti/resolve/main/config.json''',
    # See all GLPN models at https://huggingface.co/models?filter=glpn
}







class       a							(   a__  ):
 snake_case__             =       '''glpn'''



 def __init__(     self				,       _snake_case=3				,       _snake_case=4				,       _snake_case=[2, 2, 2, 2]				,       _snake_case=[8, 4, 2, 1]				,       _snake_case=[32, 64, 1_60, 2_56]				,       _snake_case=[7, 3, 3, 3]				,       _snake_case=[4, 2, 2, 2]				,       _snake_case=[1, 2, 5, 8]				,       _snake_case=[4, 4, 4, 4]				,       _snake_case="gelu"				,       _snake_case=0.0				,       _snake_case=0.0				,       _snake_case=0.02				,       _snake_case=0.1				,       _snake_case=1E-6				,       _snake_case=64				,       _snake_case=10				,       _snake_case=-1				,       **_snake_case				,       ):







  """simple docstring"""






  super().__init__(**_snake_case     )

  lowerCAmelCase    				= num_channels
  lowerCAmelCase    				= num_encoder_blocks
  lowerCAmelCase    				= depths
  lowerCAmelCase    				= sr_ratios
  lowerCAmelCase    				= hidden_sizes
  lowerCAmelCase    				= patch_sizes
  lowerCAmelCase    				= strides
  lowerCAmelCase    				= mlp_ratios
  lowerCAmelCase    				= num_attention_heads
  lowerCAmelCase    				= hidden_act
  lowerCAmelCase    				= hidden_dropout_prob
  lowerCAmelCase    				= attention_probs_dropout_prob
  lowerCAmelCase    				= initializer_range
  lowerCAmelCase    				= drop_path_rate
  lowerCAmelCase    				= layer_norm_eps
  lowerCAmelCase    				= decoder_hidden_size
  lowerCAmelCase    				= max_depth
  lowerCAmelCase    				= head_in_index





