






'''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						( _UpperCAmelCase       ,	_UpperCAmelCase       ,	_UpperCAmelCase       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=None			)					->					str:






					"""simple docstring"""







					if "." in tensor_name:
										a_						= tensor_name.split('.'			)
										for split in splits[:-1]:
															a_						= getattr(_A       ,	_A			)
															if new_module is None:
																				raise ValueError(F'''{module} has no attribute {split}.'''			)
															a_						= new_module
										a_						= 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}.'''			)
					a_						= tensor_name in module._buffers
					a_						= getattr(_A       ,	_A			)

					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}.'''			)

					a_						= False
					a_						= False
					if is_buffer or not is_bitsandbytes_available():
										a_						= False
										a_						= False
					else:
										a_						= hasattr(bnb.nn       ,	'Params4bit'			) and isinstance(module._parameters[tensor_name]       ,	bnb.nn.Paramsabit			)
										a_						= isinstance(module._parameters[tensor_name]       ,	bnb.nn.IntaParams			)

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

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

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

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

										if is_buffer:
															a_						= new_value
										else:
															a_						= nn.Parameter(_A       ,	requires_grad=old_value.requires_grad			)
															a_						= new_value

def 				a						( _UpperCAmelCase       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=False			)					->					List[Any]:






					"""simple docstring"""







					for name, module in model.named_children():
										if current_key_name is None:
															a_						= []
										current_key_name.append(_A			)

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

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

def 				a						( _UpperCAmelCase       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=None       ,	_UpperCAmelCase=None			)					->					Any:






					"""simple docstring"""







					a_						= ['lm_head'] if modules_to_not_convert is None else modules_to_not_convert
					a_				,       a_						= _replace_with_bnb_linear(
					    _A       ,	_A       ,	_A       ,	_A			)

					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						( *_UpperCAmelCase       ,	**_UpperCAmelCase			)					->					Optional[Any]:






					"""simple docstring"""







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

def 				a						( *_UpperCAmelCase       ,	**_UpperCAmelCase			)					->					List[str]:






					"""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'       ,	_A       ,	)
					return set_module_quantized_tensor_to_device(*_A       ,	**_A			)





def 				a						( _UpperCAmelCase			)					->					List[Any]:






					"""simple docstring"""







					a_						= deepcopy(_A			)  # this has 0 cost since it is done inside `init_empty_weights` context manager`
					tied_model.tie_weights()

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

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

					# add last module together with tied weights
					a_						= set(_A			) - set(_A			)
					a_						= list(set(_A			)			) + list(_A			)

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

					return filtered_module_names


'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


__lowercase        =    {
    '''configuration_chinese_clip''': [
        '''CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''ChineseCLIPConfig''',
        '''ChineseCLIPOnnxConfig''',
        '''ChineseCLIPTextConfig''',
        '''ChineseCLIPVisionConfig''',
    ],
    '''processing_chinese_clip''': ['''ChineseCLIPProcessor'''],
}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    ['''ChineseCLIPFeatureExtractor''']
						__lowercase        =    ['''ChineseCLIPImageProcessor''']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase        =    [
						    '''CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''ChineseCLIPModel''',
						    '''ChineseCLIPPreTrainedModel''',
						    '''ChineseCLIPTextModel''',
						    '''ChineseCLIPVisionModel''',
						]

if TYPE_CHECKING:
						from .configuration_chinese_clip import (
						    CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    ChineseCLIPConfig,
						    ChineseCLIPOnnxConfig,
						    ChineseCLIPTextConfig,
						    ChineseCLIPVisionConfig,
						)
						from .processing_chinese_clip import ChineseCLIPProcessor

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_chinese_clip import (
												    CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ChineseCLIPModel,
												    ChineseCLIPPreTrainedModel,
												    ChineseCLIPTextModel,
												    ChineseCLIPVisionModel,
												)

else:
						import sys

						__lowercase        =    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




