

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


__UpperCAmelCase =				logging.get_logger(__name__)







@dataclass
class      __lowercase			:

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






   '''simple docstring'''
   UpperCAmelCase__					:  int					   =					load_in_abit
   UpperCAmelCase__					:  List[str]					   =					load_in_abit
   UpperCAmelCase__					:  int					   =					llm_inta_threshold
   UpperCAmelCase__					:  Optional[Any]					   =					llm_inta_skip_modules
   UpperCAmelCase__					:  Union[str, Any]					   =					llm_inta_enable_fpaa_cpu_offload
   UpperCAmelCase__					:  Optional[Any]					   =					llm_inta_has_fpaa_weight
   UpperCAmelCase__					:  Dict					   =					bnb_abit_quant_type
   UpperCAmelCase__					:  Optional[int]					   =					bnb_abit_use_double_quant

   if bnb_abit_compute_dtype is None:
    UpperCAmelCase__					:  Dict					   =					torch.floataa
   elif isinstance(A					,A    ):
    UpperCAmelCase__					:  Optional[int]					   =					getattr(A					,A    )
   elif isinstance(A					,torch.dtype    ):
    UpperCAmelCase__					:  Dict					   =					bnb_abit_compute_dtype
   else:
    raise ValueError("""bnb_4bit_compute_dtype must be a string or a torch.dtype"""    )

   self.post_init()

  def    __lowercase       (  self		:			str    ):






   '''simple docstring'''
   if not isinstance(self.llm_inta_threshold					,A    ):
    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					,A    ):
    raise ValueError("""llm_int8_skip_modules must be a list of strings"""    )
   if not isinstance(self.llm_inta_enable_fpaa_cpu_offload					,A    ):
    raise ValueError("""llm_int8_enable_fp32_cpu_offload must be a boolean"""    )

   if not isinstance(self.llm_inta_has_fpaa_weight					,A    ):
    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					,A    ):
    raise ValueError("""bnb_4bit_quant_type must be a string"""    )

   if not isinstance(self.bnb_abit_use_double_quant					,A    ):
    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    __lowercase       (  self		:			Dict    ):






   '''simple docstring'''
   return self.load_in_abit or self.load_in_abit

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






   '''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    __lowercase       (  cls		:			List[Any]					,A		:			str					,A		:			Any					,**A		:			str    ):






   '''simple docstring'''
   UpperCAmelCase__					:  Dict					   =					cls(**A    )

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

   if return_unused_kwargs:
    return config, kwargs
   else:
    return config

  def    __lowercase       (  self		:			Union[str, Any]					,A		:			Union[str, os.PathLike]    ):






   '''simple docstring'''
   with open(A					,"""w"""					,encoding="""utf-8"""    ) as writer:
    UpperCAmelCase__					:  Dict					   =					self.to_dict()
    UpperCAmelCase__					:  Optional[Any]					   =					json.dumps(A					,indent=2					,sort_keys=A    ) + """\n"""

    writer.write(A    )

  def    __lowercase       (  self		:			List[str]    ):






   '''simple docstring'''
   UpperCAmelCase__					:  str					   =					copy.deepcopy(self.__dict__    )
   UpperCAmelCase__					:  Any					   =					str(output["""bnb_4bit_compute_dtype"""]    ).split("""."""    )[1]

   return output

  def __repr__(  self		:			Any    ):






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

  def    __lowercase       (  self		:			Tuple					,A		:			bool = True    ):






   '''simple docstring'''
   if use_diff is True:
    UpperCAmelCase__					:  int					   =					self.to_diff_dict()
   else:
    UpperCAmelCase__					:  List[str]					   =					self.to_dict()
   return json.dumps(A					,indent=2					,sort_keys=A    ) + "\n"




  def    __lowercase       (  self		:			int    ):






   '''simple docstring'''
   UpperCAmelCase__					:  Tuple					   =					self.to_dict()

   # get the default config dict
   UpperCAmelCase__					:  List[Any]					   =					BitsAndBytesConfig().to_dict()

   UpperCAmelCase__					:  str					   =					{}

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

   return serializable_config_dict








"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase =				{
    'configuration_roberta': ['ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RobertaConfig', 'RobertaOnnxConfig'],
    'tokenization_roberta': ['RobertaTokenizer'],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				['RobertaTokenizerFast']

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
          'RobertaForCausalLM',
          'RobertaForMaskedLM',
          'RobertaForMultipleChoice',
          'RobertaForQuestionAnswering',
          'RobertaForSequenceClassification',
          'RobertaForTokenClassification',
          'RobertaModel',
          'RobertaPreTrainedModel',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFRobertaForCausalLM',
          'TFRobertaForMaskedLM',
          'TFRobertaForMultipleChoice',
          'TFRobertaForQuestionAnswering',
          'TFRobertaForSequenceClassification',
          'TFRobertaForTokenClassification',
          'TFRobertaMainLayer',
          'TFRobertaModel',
          'TFRobertaPreTrainedModel',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase =				[
          'FlaxRobertaForCausalLM',
          'FlaxRobertaForMaskedLM',
          'FlaxRobertaForMultipleChoice',
          'FlaxRobertaForQuestionAnswering',
          'FlaxRobertaForSequenceClassification',
          'FlaxRobertaForTokenClassification',
          'FlaxRobertaModel',
          'FlaxRobertaPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig, RobertaOnnxConfig
      from .tokenization_roberta import RobertaTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_roberta_fast import RobertaTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_roberta import (
                ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                RobertaForCausalLM,
                RobertaForMaskedLM,
                RobertaForMultipleChoice,
                RobertaForQuestionAnswering,
                RobertaForSequenceClassification,
                RobertaForTokenClassification,
                RobertaModel,
                RobertaPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_roberta import (
                TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFRobertaForCausalLM,
                TFRobertaForMaskedLM,
                TFRobertaForMultipleChoice,
                TFRobertaForQuestionAnswering,
                TFRobertaForSequenceClassification,
                TFRobertaForTokenClassification,
                TFRobertaMainLayer,
                TFRobertaModel,
                TFRobertaPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_roberta import (
                FlaxRobertaForCausalLM,
                FlaxRobertaForMaskedLM,
                FlaxRobertaForMultipleChoice,
                FlaxRobertaForQuestionAnswering,
                FlaxRobertaForSequenceClassification,
                FlaxRobertaForTokenClassification,
                FlaxRobertaModel,
                FlaxRobertaPreTrainedModel,
            )

else:
      import sys

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





