






'''simple docstring'''




# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import copy
import importlib.metadata
import json
import os
from dataclasses import dataclass
from typing import Any, Dict, Union

from packaging import version

from ..utils import is_torch_available, logging


if is_torch_available():
    import torch


lowerCamelCase_												=					logging.get_logger(__name__)

@dataclass
class    _UpperCAmelCase			:




   """simple docstring"""

   def __init__(		self :	Optional[int]      ,      __UpperCAmelCase :	Any=False      ,      __UpperCAmelCase :	Tuple=False      ,      __UpperCAmelCase :	Any=6.0      ,      __UpperCAmelCase :	Optional[Any]=None      ,      __UpperCAmelCase :	Any=False      ,      __UpperCAmelCase :	List[Any]=False      ,      __UpperCAmelCase :	Optional[Any]=None      ,      __UpperCAmelCase :	List[Any]="fp4"      ,      __UpperCAmelCase :	List[str]=False      ,      **__UpperCAmelCase :	List[str]      ,      ):





         '''simple docstring'''





         _A			     =	load_in_abit
         _A			     =	load_in_abit
         _A			     =	llm_inta_threshold
         _A			     =	llm_inta_skip_modules
         _A			     =	llm_inta_enable_fpaa_cpu_offload
         _A			     =	llm_inta_has_fpaa_weight
         _A			     =	bnb_abit_quant_type
         _A			     =	bnb_abit_use_double_quant

         if bnb_abit_compute_dtype is None:
               _A			     =	torch.floataa
         elif isinstance(__UpperCAmelCase      ,      __UpperCAmelCase		):
               _A			     =	getattr(__UpperCAmelCase      ,      __UpperCAmelCase		)
         elif isinstance(__UpperCAmelCase      ,      torch.dtype		):
               _A			     =	bnb_abit_compute_dtype
         else:
               raise ValueError("bnb_4bit_compute_dtype must be a string or a torch.dtype"		)

         self.post_init()

   def 						lowerCAmelCase (		self :	int		):





         '''simple docstring'''





         if not isinstance(self.llm_inta_threshold      ,      __UpperCAmelCase		):
               raise ValueError("llm_int8_threshold must be a float"		)

         if self.llm_inta_skip_modules is not None and not isinstance(self.llm_inta_skip_modules      ,      __UpperCAmelCase		):
               raise ValueError("llm_int8_skip_modules must be a list of strings"		)
         if not isinstance(self.llm_inta_enable_fpaa_cpu_offload      ,      __UpperCAmelCase		):
               raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"		)

         if not isinstance(self.llm_inta_has_fpaa_weight      ,      __UpperCAmelCase		):
               raise ValueError("llm_int8_has_fp16_weight must be a boolean"		)

         if self.bnb_abit_compute_dtype is not None and not isinstance(self.bnb_abit_compute_dtype      ,      torch.dtype		):
               raise ValueError("bnb_4bit_compute_dtype must be torch.dtype"		)

         if not isinstance(self.bnb_abit_quant_type      ,      __UpperCAmelCase		):
               raise ValueError("bnb_4bit_quant_type must be a string"		)

         if not isinstance(self.bnb_abit_use_double_quant      ,      __UpperCAmelCase		):
               raise ValueError("bnb_4bit_use_double_quant must be a boolean"		)

         if self.load_in_abit and not version.parse(importlib.metadata.version("bitsandbytes"		)		) >= version.parse(
             "0.39.0"		):
               raise ValueError(
                   "4 bit quantization requires bitsandbytes>=0.39.0 - please upgrade your bitsandbytes version"		)

   def 						lowerCAmelCase (		self :	Dict		):





         '''simple docstring'''





         return self.load_in_abit or self.load_in_abit

   def 						lowerCAmelCase (		self :	int		):





         '''simple docstring'''





         if self.load_in_abit:
               return "llm_int8"
         elif self.load_in_abit and self.bnb_abit_quant_type == "fp4":
               return "fp4"
         elif self.load_in_abit and self.bnb_abit_quant_type == "nf4":
               return "nf4"
         else:
               return None

   @classmethod
   def 						lowerCAmelCase (		cls :	Optional[int]      ,      __UpperCAmelCase :	str      ,      __UpperCAmelCase :	str      ,      **__UpperCAmelCase :	Dict		):





         '''simple docstring'''





         _A			     =	cls(**__UpperCAmelCase		)

         _A			     =	[]
         for key, value in kwargs.items():
               if hasattr(__UpperCAmelCase      ,      __UpperCAmelCase		):
                     setattr(__UpperCAmelCase      ,      __UpperCAmelCase      ,      __UpperCAmelCase		)
                     to_remove.append(__UpperCAmelCase		)
         for key in to_remove:
               kwargs.pop(__UpperCAmelCase      ,      __UpperCAmelCase		)

         if return_unused_kwargs:
               return config, kwargs
         else:
               return config

   def 						lowerCAmelCase (		self :	int      ,      __UpperCAmelCase :	Union[str, os.PathLike]		):





         '''simple docstring'''





         with open(__UpperCAmelCase      ,      "w"      ,      encoding="utf-8"		) as writer:
               _A			     =	self.to_dict()
               _A			     =	json.dumps(__UpperCAmelCase      ,      indent=2      ,      sort_keys=__UpperCAmelCase		) + "\n"

               writer.write(__UpperCAmelCase		)

   def 						lowerCAmelCase (		self :	Any		):





         '''simple docstring'''





         _A			     =	copy.deepcopy(self.__dict__		)
         _A			     =	str(output["bnb_4bit_compute_dtype"]		).split("."		)[1]

         return output

   def __repr__(		self :	List[Any]		):





         '''simple docstring'''





         return f'''{self.__class__.__name__} {self.to_json_string()}'''

   def 						lowerCAmelCase (		self :	Optional[Any]      ,      __UpperCAmelCase :	bool = True		):





         '''simple docstring'''





         if use_diff is True:
               _A			     =	self.to_diff_dict()
         else:
               _A			     =	self.to_dict()
         return json.dumps(__UpperCAmelCase      ,      indent=2      ,      sort_keys=__UpperCAmelCase		) + "\n"

   def 						lowerCAmelCase (		self :	Union[str, Any]		):





         '''simple docstring'''





         _A			     =	self.to_dict()

         # get the default config dict
         _A			     =	BitsAndBytesConfig().to_dict()

         _A			     =	{}

         # only serialize values that differ from the default config
         for key, value in config_dict.items():
               if value != default_config_dict[key]:
                     _A			     =	value

         return serializable_config_dict












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case__					:							Optional[Any]													=     {'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__					:							List[str]													=     [
           'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
           'IBertForMaskedLM',
           'IBertForMultipleChoice',
           'IBertForQuestionAnswering',
           'IBertForSequenceClassification',
           'IBertForTokenClassification',
           'IBertModel',
           'IBertPreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_ibert import (
                  IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  IBertForMaskedLM,
                  IBertForMultipleChoice,
                  IBertForQuestionAnswering,
                  IBertForSequenceClassification,
                  IBertForTokenClassification,
                  IBertModel,
                  IBertPreTrainedModel,
              )

else:
       import sys

       snake_case__					:							Dict													=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





