
"""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    _lowerCAmelCase    (     lowerCamelCase__							:							Optional[Any]				)  ->    List[str]:





  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  ):
         def __init__(     self  ,     snake_case__  ,     snake_case__				):




           """simple docstring"""


           super().__init__()
           _SCREAMING_SNAKE_CASE   :				Tuple							    = module
           _SCREAMING_SNAKE_CASE   :				List[str]							    = nn.Sequential(
               nn.Linear(module.in_features  ,     __a  ,     bias=__a				)  ,     nn.Linear(__a  ,     module.out_features  ,     bias=__a				)  ,     )
           _SCREAMING_SNAKE_CASE   :				Any							    = (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  ,     snake_case__  ,     *snake_case__  ,     **snake_case__				):




           """simple docstring"""


           return self.module(__a  ,     *__a  ,     **__a				) + self.adapter(__a				)
@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class 			UpperCamelCase      (							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
     A__      =			"""bigscience/bloom-1b7"""

     # Constant values
     A__      =			2.109_6595_5269_2574

     A__      =			"""Hello my name is"""
     A__      =			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"""  )
     A__      =			10
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				int							    = AutoTokenizer.from_pretrained(self.model_name				)
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().setUp()

       # Models and tokenizer
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = AutoModelForCausalLM.from_pretrained(
           self.model_name  ,     torch_dtype=torch.floataa  ,     device_map="auto"				)
       _SCREAMING_SNAKE_CASE   :				int							    = AutoModelForCausalLM.from_pretrained(self.model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       del self.model_fpaa
       del self.model_abit

       gc.collect()
       torch.cuda.empty_cache()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = self.model_abit.config

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

       _SCREAMING_SNAKE_CASE   :				Dict							    = config.to_dict()
       _SCREAMING_SNAKE_CASE   :				Tuple							    = config.to_diff_dict()

       _SCREAMING_SNAKE_CASE   :				List[Any]							    = config.to_json_string()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       from bitsandbytes.nn import Paramsabit

       _SCREAMING_SNAKE_CASE   :				Dict							    = self.model_fpaa.get_memory_footprint()
       _SCREAMING_SNAKE_CASE   :				Tuple							    = self.model_abit.get_memory_footprint()

       self.assertAlmostEqual(mem_fpaa / mem_abit  ,     self.EXPECTED_RELATIVE_DIFFERENCE				)
       _SCREAMING_SNAKE_CASE   :				List[str]							    = get_some_linear_layer(self.model_abit				)
       self.assertTrue(linear.weight.__class__ == Paramsabit				)
     def 				__SCREAMING_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(__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				):




       """simple docstring"""


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




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Dict							    = BitsAndBytesConfig()
       _SCREAMING_SNAKE_CASE   :				Any							    = True

       _SCREAMING_SNAKE_CASE   :				Dict							    = AutoModelForCausalLM.from_pretrained(
           self.model_name  ,     quantization_config=__a  ,     device_map="auto"				)

       _SCREAMING_SNAKE_CASE   :				Tuple							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				)
       _SCREAMING_SNAKE_CASE   :				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				):




       """simple docstring"""


       with self.assertRaises(__a				), tempfile.TemporaryDirectory() as tmpdirname:
         self.model_abit.save_pretrained(__a				)
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Dict							    = BitsAndBytesConfig()

       with self.assertRaises(__a				):
         _SCREAMING_SNAKE_CASE   :				List[Any]							    = 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				):




       """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
       _SCREAMING_SNAKE_CASE   :				Dict							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				)

       _SCREAMING_SNAKE_CASE   :				List[str]							    = self.model_fpaa.to(torch.floataa				)
       _SCREAMING_SNAKE_CASE   :				List[str]							    = self.model_fpaa.generate(input_ids=encoded_input["input_ids"].to(0				)  ,     max_new_tokens=10				)

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

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

       # Check this does not throw an error
       _SCREAMING_SNAKE_CASE   :				List[str]							    = self.model_fpaa.float()




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = 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 			UpperCamelCase      (							unittest.TestCase  ):
     @classmethod
     def 				__SCREAMING_SNAKE_CASE							(     cls				):




       """simple docstring"""


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




       """simple docstring"""


       gc.collect()
       torch.cuda.empty_cache()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       from transformers import TaForConditionalGeneration

       _SCREAMING_SNAKE_CASE   :				List[str]							    = TaForConditionalGeneration._keep_in_fpaa_modules
       _SCREAMING_SNAKE_CASE   :				List[str]							    = None

       # test with `t5-small`
       _SCREAMING_SNAKE_CASE   :				Any							    = TaForConditionalGeneration.from_pretrained(self.model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
       _SCREAMING_SNAKE_CASE   :				int							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				).to(0				)
       _SCREAMING_SNAKE_CASE   :				Tuple							    = model.generate(**__a				)

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




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       import bitsandbytes as bnb

       from transformers import TaForConditionalGeneration

       # test with `t5-small`
       _SCREAMING_SNAKE_CASE   :				int							    = 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				)				)

       _SCREAMING_SNAKE_CASE   :				Any							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				).to(0				)
       _SCREAMING_SNAKE_CASE   :				Any							    = model.generate(**__a				)

       # test with `flan-t5-small`
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = TaForConditionalGeneration.from_pretrained(
           self.dense_act_model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
       _SCREAMING_SNAKE_CASE   :				Optional[int]							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				).to(0				)
       _SCREAMING_SNAKE_CASE   :				List[str]							    = model.generate(**__a				)
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().setUp()
       # model_name
       _SCREAMING_SNAKE_CASE   :				Dict							    = "bigscience/bloom-560m"
       _SCREAMING_SNAKE_CASE   :				Optional[Any]							    = "t5-small"

       # Different types of model

       _SCREAMING_SNAKE_CASE   :				Any							    = AutoModel.from_pretrained(self.model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
       # Sequence classification model
       _SCREAMING_SNAKE_CASE   :				Tuple							    = AutoModelForSequenceClassification.from_pretrained(
           self.model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
       # CausalLM model
       _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = AutoModelForCausalLM.from_pretrained(self.model_name  ,     load_in_abit=__a  ,     device_map="auto"				)
       # Seq2seq model
       _SCREAMING_SNAKE_CASE   :				Tuple							    = AutoModelForSeqaSeqLM.from_pretrained(
           self.seq_to_seq_name  ,     load_in_abit=__a  ,     device_map="auto"				)
     def 				__SCREAMING_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 				__SCREAMING_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 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().setUp()
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       del self.pipe

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




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				List[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
       _SCREAMING_SNAKE_CASE   :				Any							    = self.pipe(self.input_text				)
       self.assertIn(pipeline_output[0]["generated_text"]  ,     self.EXPECTED_OUTPUTS				)
@require_torch_multi_gpu
class 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       super().setUp()




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Tuple							    = 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
       _SCREAMING_SNAKE_CASE   :				int							    = self.tokenizer(self.input_text  ,     return_tensors="pt"				)

       # Second real batch
       _SCREAMING_SNAKE_CASE   :				List[str]							    = 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 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


       _SCREAMING_SNAKE_CASE   :				Any							    = "facebook/opt-350m"
       super().setUp()




     def 				__SCREAMING_SNAKE_CASE							(     self				):




       """simple docstring"""


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

       # Step 1: freeze all parameters
       _SCREAMING_SNAKE_CASE   :				List[Any]							    = 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():
         _SCREAMING_SNAKE_CASE   :				int							    = False  # freeze the model - train adapters later
         if param.ndim == 1:
           # cast the small parameters (e.g. layernorm) to fp32 for stability
           _SCREAMING_SNAKE_CASE   :				Optional[int]							    = param.data.to(torch.floataa				)

        # Step 2: add adapters
       for _, module in model.named_modules():
         if "OPTAttention" in repr(type(__a				)				):
           _SCREAMING_SNAKE_CASE   :				Union[str, Any]							    = LoRALayer(module.q_proj  ,     rank=16				)
           _SCREAMING_SNAKE_CASE   :				Dict							    = LoRALayer(module.k_proj  ,     rank=16				)
           _SCREAMING_SNAKE_CASE   :				str							    = LoRALayer(module.v_proj  ,     rank=16				)

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

       # Step 4: Check if the gradient is not None
       with torch.cuda.amp.autocast():
         _SCREAMING_SNAKE_CASE   :				List[Any]							    = 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 			UpperCamelCase      (							__SCREAMING_SNAKE_CASE  ):
     A__      =			"""gpt2-xl"""
     A__      =			3.3191_8548_5415_2187





"""simple docstring"""
def    _lowerCAmelCase    (     lowerCamelCase__							:							str,						lowerCamelCase__							:							str				)  ->    Union[str, Any]:
  print("\nThe shortest path matrix using Floyd Warshall algorithm\n"				)
  for i in range(lowerCamelCase__				):
    for j in range(lowerCamelCase__				):
      if dist[i][j] != float("inf"				):
        print(int(dist[i][j]				),						end="\t"				)
      else:
        print("INF",						end="\t"				)
    print()





def    _lowerCAmelCase    (     lowerCamelCase__							:							Dict,						lowerCamelCase__							:							Any				)  ->    List[str]:
  _SCREAMING_SNAKE_CASE   :				List[Any]							    = [[float("inf"				) for _ in range(lowerCamelCase__				)] for _ in range(lowerCamelCase__				)]

  for i in range(lowerCamelCase__				):
    for j in range(lowerCamelCase__				):
      _SCREAMING_SNAKE_CASE   :				List[Any]							    = graph[i][j]

      # check vertex k against all other vertices (i, j)
  for k in range(lowerCamelCase__				):
    # looping through rows of graph array
    for i in range(lowerCamelCase__				):
      # looping through columns of graph array
      for j in range(lowerCamelCase__				):
        if (
            dist[i][k] != float("inf"				)
            and dist[k][j] != float("inf"				)
            and dist[i][k] + dist[k][j] < dist[i][j]
        ):
          _SCREAMING_SNAKE_CASE   :				List[Any]							    = dist[i][k] + dist[k][j]

  _print_dist(lowerCamelCase__,						lowerCamelCase__				)
  return dist, v


if __name__ == "__main__":
      lowercase_       :						Tuple     					=	int(input('''Enter number of vertices: '''))
      lowercase_       :						List[Any]     					=	int(input('''Enter number of edges: '''))

      lowercase_       :						Optional[Any]     					=	[[float('''inf''') for i in range(v)] for j in range(v)]

      for i in range(v):
            lowercase_       :						Tuple     					=	0.0

            # src and dst are indices that must be within the array size graph[e][v]
            # failure to follow this will result in an error
      for i in range(e):
            print('''\nEdge ''', i + 1)
            lowercase_       :						str     					=	int(input('''Enter source:'''))
            lowercase_       :						Optional[Any]     					=	int(input('''Enter destination:'''))
            lowercase_       :						Union[str, Any]     					=	float(input('''Enter weight:'''))
            lowercase_       :						str     					=	weight

      floyd_warshall(graph, v)

      # Example Input
      # Enter number of vertices: 3
      # Enter number of edges: 2

      # # generated graph from vertex and edge inputs
      # [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
      # [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

      # specify source, destination and weight for edge #1
      # Edge  1
      # Enter source:1
      # Enter destination:2
      # Enter weight:2

      # specify source, destination and weight for edge #2
      # Edge  2
      # Enter source:2
      # Enter destination:1
      # Enter weight:1

      # # Expected Output from the vertice, edge and src, dst, weight inputs!!
      # 0		INF	INF
      # INF	0	2
      # INF	1	0



