


"""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

__UpperCamelCase						=      logging.get_logger(__name__)


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

						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													=					False
						SCREAMING_SNAKE_CASE													=					False
						if is_buffer or not is_bitsandbytes_available():
												SCREAMING_SNAKE_CASE													=					False
												SCREAMING_SNAKE_CASE													=					False
						else:
												SCREAMING_SNAKE_CASE													=					hasattr(bnb.nn ,			'Params4bit'  ) and isinstance(module._parameters[tensor_name] ,			bnb.nn.Paramsabit  )
												SCREAMING_SNAKE_CASE													=					isinstance(module._parameters[tensor_name] ,			bnb.nn.IntaParams  )

						if is_abit or is_abit:
												SCREAMING_SNAKE_CASE													=					module._parameters[tensor_name]
												if param.device.type != "cuda":
																		if value is None:
																								SCREAMING_SNAKE_CASE													=					old_value.to(SCREAMING_SNAKE_CASE_  )
																		elif isinstance(SCREAMING_SNAKE_CASE_ ,			torch.Tensor  ):
																								SCREAMING_SNAKE_CASE													=					value.to('cpu'  )
																								if value.dtype == torch.inta:
																														SCREAMING_SNAKE_CASE													=					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													=					torch.tensor(SCREAMING_SNAKE_CASE_ ,			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 ,			SCREAMING_SNAKE_CASE_  ) and fpaa_statistics is None:
																								SCREAMING_SNAKE_CASE													=					new_value.T

																		SCREAMING_SNAKE_CASE													=					old_value.__dict__
																		if is_abit:
																								SCREAMING_SNAKE_CASE													=					bnb.nn.IntaParams(SCREAMING_SNAKE_CASE_ ,			requires_grad=SCREAMING_SNAKE_CASE_ ,			**SCREAMING_SNAKE_CASE_  ).to(SCREAMING_SNAKE_CASE_  )
																		elif is_abit:
																								SCREAMING_SNAKE_CASE													=					bnb.nn.Paramsabit(SCREAMING_SNAKE_CASE_ ,			requires_grad=SCREAMING_SNAKE_CASE_ ,			**SCREAMING_SNAKE_CASE_  ).to(SCREAMING_SNAKE_CASE_  )

																		SCREAMING_SNAKE_CASE													=					new_value
																		if fpaa_statistics is not None:
																								setattr(module.weight ,			'SCB' ,			fpaa_statistics.to(SCREAMING_SNAKE_CASE_  )  )

						else:
												if value is None:
																		SCREAMING_SNAKE_CASE													=					old_value.to(SCREAMING_SNAKE_CASE_  )
												elif isinstance(SCREAMING_SNAKE_CASE_ ,			torch.Tensor  ):
																		SCREAMING_SNAKE_CASE													=					value.to(SCREAMING_SNAKE_CASE_  )
												else:
																		SCREAMING_SNAKE_CASE													=					torch.tensor(SCREAMING_SNAKE_CASE_ ,			device=SCREAMING_SNAKE_CASE_  )

												if is_buffer:
																		SCREAMING_SNAKE_CASE													=					new_value
												else:
																		SCREAMING_SNAKE_CASE													=					nn.Parameter(SCREAMING_SNAKE_CASE_ ,			requires_grad=old_value.requires_grad  )
																		SCREAMING_SNAKE_CASE													=					new_value


def     lowercase			(SCREAMING_SNAKE_CASE_		:				List[str] ,			SCREAMING_SNAKE_CASE_		:				List[Any]=None ,			SCREAMING_SNAKE_CASE_		:				Optional[int]=None ,			SCREAMING_SNAKE_CASE_		:				Any=None ,			SCREAMING_SNAKE_CASE_		:				Union[str, Any]=False  )   ->						Union[str, Any]:
						for name, module in model.named_children():
												if current_key_name is None:
																		SCREAMING_SNAKE_CASE													=					[]
												current_key_name.append(SCREAMING_SNAKE_CASE_  )

												if (isinstance(SCREAMING_SNAKE_CASE_ ,			nn.Linear  ) or isinstance(SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_  )) 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(SCREAMING_SNAKE_CASE_  ) for key in modules_to_not_convert  ):
																								with init_empty_weights():
																														if isinstance(SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_  ):
																																				SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					module.weight.shape
																														else:
																																				SCREAMING_SNAKE_CASE													=					module.in_features
																																				SCREAMING_SNAKE_CASE													=					module.out_features

																														if quantization_config.quantization_method() == "llm_int8":
																																				SCREAMING_SNAKE_CASE													=					bnb.nn.LinearabitLt(
																																				    SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			module.bias is not None ,			has_fpaa_weights=quantization_config.llm_inta_has_fpaa_weight ,			threshold=quantization_config.llm_inta_threshold ,			)
																																				SCREAMING_SNAKE_CASE													=					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													=					bnb.nn.Linearabit(
																																										    SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			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													=					True
                    # Store the module class in case we need to transpose the weight later
																														SCREAMING_SNAKE_CASE													=					type(SCREAMING_SNAKE_CASE_  )
																														# Force requires grad to False to avoid unexpected errors
																														model._modules[name].requires_grad_(SCREAMING_SNAKE_CASE_  )
												if len(list(module.children()  )  ) > 0:
																		SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					_replace_with_bnb_linear(
																		    SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			has_been_replaced=SCREAMING_SNAKE_CASE_ ,			)
												# Remove the last key for recursion
												current_key_name.pop(-1  )
						return model, has_been_replaced


def     lowercase			(SCREAMING_SNAKE_CASE_		:				Tuple ,			SCREAMING_SNAKE_CASE_		:				Any=None ,			SCREAMING_SNAKE_CASE_		:				List[str]=None ,			SCREAMING_SNAKE_CASE_		:				str=None  )   ->						Optional[Any]:
						SCREAMING_SNAKE_CASE													=					['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
						SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					_replace_with_bnb_linear(
						    SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_  )

						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     lowercase			(*SCREAMING_SNAKE_CASE_		:				Tuple ,			**SCREAMING_SNAKE_CASE_		:				int  )   ->						List[str]:
						warnings.warn(
						    '`replace_8bit_linear` will be deprecated in a future version, please use `replace_with_bnb_linear` instead' ,			SCREAMING_SNAKE_CASE_ ,			)
						return replace_with_bnb_linear(*SCREAMING_SNAKE_CASE_ ,			**SCREAMING_SNAKE_CASE_  )


def     lowercase			(*SCREAMING_SNAKE_CASE_		:				int ,			**SCREAMING_SNAKE_CASE_		:				List[str]  )   ->						Any:
						warnings.warn(
						    '`set_module_8bit_tensor_to_device` will be deprecated in a future version, please use `set_module_quantized_tensor_to_device` instead' ,			SCREAMING_SNAKE_CASE_ ,			)
						return set_module_quantized_tensor_to_device(*SCREAMING_SNAKE_CASE_ ,			**SCREAMING_SNAKE_CASE_  )


def     lowercase			(SCREAMING_SNAKE_CASE_		:				Any  )   ->						Tuple:
						SCREAMING_SNAKE_CASE													=					deepcopy(SCREAMING_SNAKE_CASE_  )  # this has 0 cost since it is done inside `init_empty_weights` context manager`
						tied_model.tie_weights()

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

						# Check if it is a base model
						SCREAMING_SNAKE_CASE													=					not hasattr(SCREAMING_SNAKE_CASE_ ,			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(model.named_children()  )
						SCREAMING_SNAKE_CASE													=					[list_modules[-1][0]]

						# add last module together with tied weights
						SCREAMING_SNAKE_CASE													=					set(SCREAMING_SNAKE_CASE_  ) - set(SCREAMING_SNAKE_CASE_  )
						SCREAMING_SNAKE_CASE													=					list(set(SCREAMING_SNAKE_CASE_  )  ) + list(SCREAMING_SNAKE_CASE_  )

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

						return filtered_module_names






"""simple docstring"""




from math import isclose, sqrt


def     lowercase			(SCREAMING_SNAKE_CASE_		:				float ,			SCREAMING_SNAKE_CASE_		:				float ,			SCREAMING_SNAKE_CASE_		:				float  )   ->						tuple[float, float, float]:
						SCREAMING_SNAKE_CASE													=					point_y / 4 / point_x
						SCREAMING_SNAKE_CASE													=					2 * normal_gradient / (1 + normal_gradient * normal_gradient)
						SCREAMING_SNAKE_CASE													=					(1 - normal_gradient * normal_gradient) / (
						    1 + normal_gradient * normal_gradient
						)
						SCREAMING_SNAKE_CASE													=					(sa - ca * incoming_gradient) / (ca + sa * incoming_gradient)

						# to find the next point, solve the simultaeneous equations:
						# y^2 + 4x^2 = 100
						# y - b = m * (x - a)
						# ==> A x^2 + B x + C = 0
						SCREAMING_SNAKE_CASE													=					outgoing_gradient**2 + 4
						SCREAMING_SNAKE_CASE													=					2 * outgoing_gradient * (point_y - outgoing_gradient * point_x)
						SCREAMING_SNAKE_CASE													=					(point_y - outgoing_gradient * point_x) ** 2 - 1_00

						SCREAMING_SNAKE_CASE													=					(
						    -linear_term - sqrt(linear_term**2 - 4 * quadratic_term * constant_term  )
						) / (2 * quadratic_term)
						SCREAMING_SNAKE_CASE													=					(
						    -linear_term + sqrt(linear_term**2 - 4 * quadratic_term * constant_term  )
						) / (2 * quadratic_term)

						# two solutions, one of which is our input point
						SCREAMING_SNAKE_CASE													=					x_minus if isclose(SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_  ) else x_plus
						SCREAMING_SNAKE_CASE													=					point_y + outgoing_gradient * (next_x - point_x)

						return next_x, next_y, outgoing_gradient


def     lowercase			(SCREAMING_SNAKE_CASE_		:				float = 1.4 ,			SCREAMING_SNAKE_CASE_		:				float = -9.6  )   ->						int:
						SCREAMING_SNAKE_CASE													=					0
						SCREAMING_SNAKE_CASE													=					first_x_coord
						SCREAMING_SNAKE_CASE													=					first_y_coord
						SCREAMING_SNAKE_CASE													=					(10.1 - point_y) / (0.0 - point_x)

						while not (-0.01 <= point_x <= 0.01 and point_y > 0):
												SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE							,				SCREAMING_SNAKE_CASE													=					next_point(SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_ ,			SCREAMING_SNAKE_CASE_  )
												num_reflections += 1

						return num_reflections


if __name__ == "__main__":
	print(f'''{solution() = }''')


