






import importlib.metadata
import warnings
from copy import deepcopy

from packaging import version

from ..utils import logging
from .import_utils import is_accelerate_available, is_bitsandbytes_available


if is_bitsandbytes_available():
   import bitsandbytes as bnb
   import torch
   import torch.nn as nn

   from ..pytorch_utils import ConvaD

if is_accelerate_available():
   from accelerate import init_empty_weights
   from accelerate.utils import find_tied_parameters

snake_case    				=		logging.get_logger(__name__)


def   lowerCamelCase__			(     lowercase						,     lowercase						,     lowercase						,     lowercase=None						,     lowercase=None				):

  """simple docstring"""






  if "." in tensor_name:
    SCREAMING_SNAKE_CASE       :      int							=    tensor_name.split("."				)
    for split in splits[:-1]:
      SCREAMING_SNAKE_CASE       :      Any							=    getattr(lowercase						,     lowercase				)
      if new_module is None:
        raise ValueError(F'''{module} has no attribute {split}.'''				)
      SCREAMING_SNAKE_CASE       :      List[Any]							=    new_module
    SCREAMING_SNAKE_CASE       :      Tuple							=    splits[-1]

  if tensor_name not in module._parameters and tensor_name not in module._buffers:
    raise ValueError(F'''{module} does not have a parameter or a buffer named {tensor_name}.'''				)
  SCREAMING_SNAKE_CASE       :      Tuple							=    tensor_name in module._buffers
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    getattr(lowercase						,     lowercase				)

  if old_value.device == torch.device("meta"				) and device not in ["meta", torch.device("meta"				)] and value is None:
    raise ValueError(F'''{tensor_name} is on the meta device, we need a `value` to put in on {device}.'''				)

  SCREAMING_SNAKE_CASE       :      int							=    False
  SCREAMING_SNAKE_CASE       :      str							=    False
  if is_buffer or not is_bitsandbytes_available():
    SCREAMING_SNAKE_CASE       :      int							=    False
    SCREAMING_SNAKE_CASE       :      List[str]							=    False
  else:
    SCREAMING_SNAKE_CASE       :      List[Any]							=    hasattr(bnb.nn						,     "Params4bit"				) and isinstance(module._parameters[tensor_name]						,     bnb.nn.Paramsabit				)
    SCREAMING_SNAKE_CASE       :      Dict							=    isinstance(module._parameters[tensor_name]						,     bnb.nn.IntaParams				)

  if is_abit or is_abit:
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    module._parameters[tensor_name]
    if param.device.type != "cuda":
      if value is None:
        SCREAMING_SNAKE_CASE       :      List[Any]							=    old_value.to(lowercase				)
      elif isinstance(lowercase						,     torch.Tensor				):
        SCREAMING_SNAKE_CASE       :      Optional[Any]							=    value.to("cpu"				)
        if value.dtype == torch.inta:
          SCREAMING_SNAKE_CASE       :      Optional[int]							=    version.parse(importlib.metadata.version("bitsandbytes"				)				) > version.parse(
              "0.37.2"				)
          if not is_abit_serializable:
            raise ValueError(
                "Detected int8 weights but the version of bitsandbytes is not compatible with int8 serialization. "
                "Make sure to download the latest `bitsandbytes` version. `pip install --upgrade bitsandbytes`."				)
      else:
        SCREAMING_SNAKE_CASE       :      List[Any]							=    torch.tensor(lowercase						,     device="cpu"				)

      # Support models using `Conv1D` in place of `nn.Linear` (e.g. gpt2) by transposing the weight matrix prior to quantization.
      # Since weights are saved in the correct "orientation", we skip transposing when loading.
      if issubclass(module.source_cls						,     lowercase				) and fpaa_statistics is None:
        SCREAMING_SNAKE_CASE       :      List[Any]							=    new_value.T

      SCREAMING_SNAKE_CASE       :      Optional[Any]							=    old_value.__dict__
      if is_abit:
        SCREAMING_SNAKE_CASE       :      Any							=    bnb.nn.IntaParams(lowercase						,     requires_grad=lowercase						,     **lowercase				).to(lowercase				)
      elif is_abit:
        SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    bnb.nn.Paramsabit(lowercase						,     requires_grad=lowercase						,     **lowercase				).to(lowercase				)

      SCREAMING_SNAKE_CASE       :      Tuple							=    new_value
      if fpaa_statistics is not None:
        setattr(module.weight						,     "SCB"						,     fpaa_statistics.to(lowercase				)				)

  else:
    if value is None:
      SCREAMING_SNAKE_CASE       :      Dict							=    old_value.to(lowercase				)
    elif isinstance(lowercase						,     torch.Tensor				):
      SCREAMING_SNAKE_CASE       :      Tuple							=    value.to(lowercase				)
    else:
      SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    torch.tensor(lowercase						,     device=lowercase				)

    if is_buffer:
      SCREAMING_SNAKE_CASE       :      List[str]							=    new_value
    else:
      SCREAMING_SNAKE_CASE       :      List[Any]							=    nn.Parameter(lowercase						,     requires_grad=old_value.requires_grad				)
      SCREAMING_SNAKE_CASE       :      str							=    new_value


def   lowerCamelCase__			(     lowercase						,     lowercase=None						,     lowercase=None						,     lowercase=None						,     lowercase=False				):

  """simple docstring"""






  for name, module in model.named_children():
    if current_key_name is None:
      SCREAMING_SNAKE_CASE       :      Tuple							=    []
    current_key_name.append(lowercase				)

    if (isinstance(lowercase						,     nn.Linear				) or isinstance(lowercase						,     lowercase				)) and name not in modules_to_not_convert:
      # Check if the current key is not in the `modules_to_not_convert`
      if not any(key in ".".join(lowercase				) for key in modules_to_not_convert				):
        with init_empty_weights():
          if isinstance(lowercase						,     lowercase				):
            SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Any							=    module.weight.shape
          else:
            SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    module.in_features
            SCREAMING_SNAKE_CASE       :      List[str]							=    module.out_features

          if quantization_config.quantization_method() == "llm_int8":
            SCREAMING_SNAKE_CASE       :      List[str]							=    bnb.nn.LinearabitLt(
                lowercase						,     lowercase						,     module.bias is not None						,     has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight						,     threshold=quantization_config.llm_inta_threshold						,     )
            SCREAMING_SNAKE_CASE       :      Optional[int]							=    True
          else:
            if (
                quantization_config.llm_inta_skip_modules is not None
                and name in quantization_config.llm_inta_skip_modules
            ):
              pass
            else:
              SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    bnb.nn.Linearabit(
                  lowercase						,     lowercase						,     module.bias is not None						,     quantization_config.bnb_abit_compute_dtype						,     compress_statistics=quantization_config.bnb_abit_use_double_quant						,     quant_type=quantization_config.bnb_abit_quant_type						,     )
              SCREAMING_SNAKE_CASE       :      Dict							=    True
                    # Store the module class in case we need to transpose the weight later
          SCREAMING_SNAKE_CASE       :      List[Any]							=    type(lowercase				)
          # Force requires grad to False to avoid unexpected errors
          model._modules[name].requires_grad_(lowercase				)
    if len(list(module.children()				)				) > 0:
      SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Tuple							=    _replace_with_bnb_linear(
          lowercase						,     lowercase						,     lowercase						,     lowercase						,     has_been_replaced=lowercase						,     )
    # Remove the last key for recursion
    current_key_name.pop(-1				)
  return model, has_been_replaced


def   lowerCamelCase__			(     lowercase						,     lowercase=None						,     lowercase=None						,     lowercase=None				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Tuple							=    ["lm_head"] if modules_to_not_convert is None else modules_to_not_convert
  SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      str							=    _replace_with_bnb_linear(
      lowercase						,     lowercase						,     lowercase						,     lowercase				)

  if not has_been_replaced:
    logger.warning(
        "You are loading your model in 8bit or 4bit but no linear modules were found in your model."
        " Please double check your model architecture, or submit an issue on github if you think this is"
        " a bug."				)

  return model


def   lowerCamelCase__			(     *lowercase						,     **lowercase				):

  """simple docstring"""






  warnings.warn(
      "`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead"						,     lowercase						,     )
  return replace_with_bnb_linear(*lowercase						,     **lowercase				)


def   lowerCamelCase__			(     *lowercase						,     **lowercase				):

  """simple docstring"""






  warnings.warn(
      "`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead"						,     lowercase						,     )
  return set_module_quantized_tensor_to_device(*lowercase						,     **lowercase				)


def   lowerCamelCase__			(     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    deepcopy(lowercase				)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
  tied_model.tie_weights()

  SCREAMING_SNAKE_CASE       :      str							=    find_tied_parameters(lowercase				)
  # For compatibility with Accelerate < 0.18
  if isinstance(lowercase						,     lowercase				):
    SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    sum(list(tied_params.values()				)						,     []				) + list(tied_params.keys()				)
  else:
    SCREAMING_SNAKE_CASE       :      List[Any]							=    sum(lowercase						,     []				)
  SCREAMING_SNAKE_CASE       :      Any							=    len(lowercase				) > 0

  # Check if it is a base model
  SCREAMING_SNAKE_CASE       :      Dict							=    not hasattr(lowercase						,     model.base_model_prefix				)

  # Ignore this for base models (BertModel, GPT2Model, etc.)
  if (not has_tied_params) and is_base_model:
    return []

  # otherwise they have an attached head
  SCREAMING_SNAKE_CASE       :      List[Any]							=    list(model.named_children()				)
  SCREAMING_SNAKE_CASE       :      int							=    [list_modules[-1][0]]

  # add last module together with tied weights
  SCREAMING_SNAKE_CASE       :      str							=    set(lowercase				) - set(lowercase				)
  SCREAMING_SNAKE_CASE       :      List[Any]							=    list(set(lowercase				)				) + list(lowercase				)

  # remove ".weight" from the keys
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    [".weight", ".bias"]
  SCREAMING_SNAKE_CASE       :      List[str]							=    []
  for name in list_untouched:
    for name_to_remove in names_to_remove:
      if name_to_remove in name:
        SCREAMING_SNAKE_CASE       :      int							=    name.replace(lowercase						,     ""				)
    filtered_module_names.append(lowercase				)

  return filtered_module_names














import qiskit


def   lowerCamelCase__			(     lowercase						,     lowercase				):

  """simple docstring"""






  SCREAMING_SNAKE_CASE       :      List[str]							=    qiskit.Aer.get_backend("aer_simulator"				)

  # Create a Quantum Circuit acting on the q register
  SCREAMING_SNAKE_CASE       :      Dict							=    qiskit.QuantumCircuit(lowercase						,     lowercase				)

  # Map the quantum measurement to the classical bits
  circuit.measure([0]						,     [0]				)

  # Execute the circuit on the simulator
  SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    qiskit.execute(lowercase						,     lowercase						,     shots=1000				)

  # Return the histogram data of the results of the experiment.
  return job.result().get_counts(lowercase				)


if __name__ == "__main__":
   print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")






