





'''simple docstring'''






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

lowerCAmelCase       		=      logging.get_logger(__name__)






def      __A						(							a_						:  Any      ,a_						:  int      ,a_						:  int      ,a_						:  Union[str, Any]=None      ,a_						:  Union[str, Any]=None	):
		# Recurse if needed
		if "." in tensor_name:
				lowerCAmelCase     :    List[str]						=   tensor_name.split("."	)
				for split in splits[:-1]:
						lowerCAmelCase     :    Optional[int]						=   getattr(_lowercase      ,_lowercase	)
						if new_module is None:
								raise ValueError(f'''{module} has no attribute {split}.'''	)
						lowerCAmelCase     :    int						=   new_module
				lowerCAmelCase     :    List[str]						=   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}.'''	)
		lowerCAmelCase     :    Union[str, Any]						=   tensor_name in module._buffers
		lowerCAmelCase     :    str						=   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}.'''	)

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

		if is_abit or is_abit:
				lowerCAmelCase     :    Any						=   module._parameters[tensor_name]
				if param.device.type != "cuda":
						if value is None:
								lowerCAmelCase     :    Union[str, Any]						=   old_value.to(_lowercase	)
						elif isinstance(_lowercase      ,torch.Tensor	):
								lowerCAmelCase     :    Dict						=   value.to("cpu"	)
								if value.dtype == torch.inta:
										lowerCAmelCase     :    List[str]						=   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:
								lowerCAmelCase     :    Union[str, 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:
								lowerCAmelCase     :    Tuple						=   new_value.T

						lowerCAmelCase     :    List[str]						=   old_value.__dict__
						if is_abit:
								lowerCAmelCase     :    List[Any]						=   bnb.nn.IntaParams(_lowercase      ,requires_grad=_lowercase      ,**_lowercase	).to(_lowercase	)
						elif is_abit:
								lowerCAmelCase     :    int						=   bnb.nn.Paramsabit(_lowercase      ,requires_grad=_lowercase      ,**_lowercase	).to(_lowercase	)

						lowerCAmelCase     :    int						=   new_value
						if fpaa_statistics is not None:
								setattr(module.weight      ,"SCB"      ,fpaa_statistics.to(_lowercase	)	)

		else:
				if value is None:
						lowerCAmelCase     :    Optional[int]						=   old_value.to(_lowercase	)
				elif isinstance(_lowercase      ,torch.Tensor	):
						lowerCAmelCase     :    int						=   value.to(_lowercase	)
				else:
						lowerCAmelCase     :    List[Any]						=   torch.tensor(_lowercase      ,device=_lowercase	)

				if is_buffer:
						lowerCAmelCase     :    int						=   new_value
				else:
						lowerCAmelCase     :    int						=   nn.Parameter(_lowercase      ,requires_grad=old_value.requires_grad	)
						lowerCAmelCase     :    Tuple						=   new_value






def      __A						(							a_						:  Tuple      ,a_						:  Optional[Any]=None      ,a_						:  Dict=None      ,a_						:  str=None      ,a_						:  Dict=False	):
		for name, module in model.named_children():
				if current_key_name is None:
						lowerCAmelCase     :    Dict						=   []
				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	):
												lowerCAmelCase     :    Optional[int]						=   module.weight.shape
										else:
												lowerCAmelCase     :    Any						=   module.in_features
												lowerCAmelCase     :    str						=   module.out_features

										if quantization_config.quantization_method() == "llm_int8":
												lowerCAmelCase     :    int						=   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      ,)
												lowerCAmelCase     :    List[str]						=   True
										else:
												if (
												    quantization_config.llm_inta_skip_modules is not None
												    and name in quantization_config.llm_inta_skip_modules
												):
														pass
												else:
														lowerCAmelCase     :    int						=   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      ,)
														lowerCAmelCase     :    Dict						=   True
                    # Store the module class in case we need to transpose the weight later
										lowerCAmelCase     :    str						=   type(_lowercase	)
										# Force requires grad to False to avoid unexpected errors
										model._modules[name].requires_grad_(_lowercase	)
				if len(list(module.children()	)	) > 0:
						lowerCAmelCase     :    str						=   _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      __A						(							a_						:  Tuple      ,a_						:  Tuple=None      ,a_						:  Optional[int]=None      ,a_						:  Union[str, Any]=None	):
		lowerCAmelCase     :    Optional[Any]						=   ['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
		lowerCAmelCase     :    List[Any]						=   _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      __A						(							*a_						:  List[str]      ,**a_						:  List[str]	):
		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      __A						(							*a_						:  Any      ,**a_						:  List[str]	):
		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      __A						(							a_						:  Any	):
		lowerCAmelCase     :    List[Any]						=   deepcopy(_lowercase	)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
		tied_model.tie_weights()

		lowerCAmelCase     :    int						=   find_tied_parameters(_lowercase	)
		# For compatibility with Accelerate < 0.18
		if isinstance(_lowercase      ,_lowercase	):
				lowerCAmelCase     :    Dict						=   sum(list(tied_params.values()	)      ,[]	) + list(tied_params.keys()	)
		else:
				lowerCAmelCase     :    List[Any]						=   sum(_lowercase      ,[]	)
		lowerCAmelCase     :    Any						=   len(_lowercase	) > 0

		# Check if it is a base model
		lowerCAmelCase     :    str						=   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
		lowerCAmelCase     :    int						=   list(model.named_children()	)
		lowerCAmelCase     :    List[str]						=   [list_modules[-1][0]]

		# add last module together with tied weights
		lowerCAmelCase     :    Optional[Any]						=   set(_lowercase	) - set(_lowercase	)
		lowerCAmelCase     :    Optional[Any]						=   list(set(_lowercase	)	) + list(_lowercase	)

		# remove ".weight" from the keys
		lowerCAmelCase     :    Dict						=   ['.weight', '.bias']
		lowerCAmelCase     :    Dict						=   []
		for name in list_untouched:
				for name_to_remove in names_to_remove:
						if name_to_remove in name:
								lowerCAmelCase     :    int						=   name.replace(_lowercase      ,""	)
				filtered_module_names.append(_lowercase	)

		return filtered_module_names










'''simple docstring'''






import numpy as np






def      __A						(							a_						:  np.array	):
		return 1 / (1 + np.exp(-vector	))


if __name__ == "__main__":
					import doctest

					doctest.testmod()



