


'''simple docstring'''



from . import (
    albert,
    align,
    altclip,
    audio_spectrogram_transformer,
    auto,
    autoformer,
    bark,
    bart,
    barthez,
    bartpho,
    beit,
    bert,
    bert_generation,
    bert_japanese,
    bertweet,
    big_bird,
    bigbird_pegasus,
    biogpt,
    bit,
    blenderbot,
    blenderbot_small,
    blip,
    blip_a,
    bloom,
    bridgetower,
    byta,
    camembert,
    canine,
    chinese_clip,
    clap,
    clip,
    clipseg,
    codegen,
    conditional_detr,
    convbert,
    convnext,
    convnextva,
    cpm,
    cpmant,
    ctrl,
    cvt,
    dataavec,
    deberta,
    deberta_va,
    decision_transformer,
    deformable_detr,
    deit,
    deprecated,
    deta,
    detr,
    dialogpt,
    dinat,
    distilbert,
    dit,
    donut,
    dpr,
    dpt,
    efficientformer,
    efficientnet,
    electra,
    encodec,
    encoder_decoder,
    ernie,
    ernie_m,
    esm,
    falcon,
    flaubert,
    flava,
    fnet,
    focalnet,
    fsmt,
    funnel,
    git,
    glpn,
    gpta,
    gpt_bigcode,
    gpt_neo,
    gpt_neox,
    gpt_neox_japanese,
    gpt_swa,
    gptj,
    gptsan_japanese,
    graphormer,
    groupvit,
    herbert,
    hubert,
    ibert,
    imagegpt,
    informer,
    instructblip,
    jukebox,
    layoutlm,
    layoutlmva,
    layoutlmva,
    layoutxlm,
    led,
    levit,
    lilt,
    llama,
    longformer,
    longta,
    luke,
    lxmert,
    mam_aaa,
    marian,
    markuplm,
    maskaformer,
    maskformer,
    mbart,
    mbartaa,
    mega,
    megatron_bert,
    megatron_gpta,
    mgp_str,
    mluke,
    mobilebert,
    mobilenet_va,
    mobilenet_va,
    mobilevit,
    mobilevitva,
    mpnet,
    mra,
    mta,
    musicgen,
    mvp,
    nat,
    nezha,
    nllb,
    nllb_moe,
    nystromformer,
    oneformer,
    open_llama,
    openai,
    opt,
    owlvit,
    pegasus,
    pegasus_x,
    perceiver,
    phobert,
    pixastruct,
    plbart,
    poolformer,
    prophetnet,
    qdqbert,
    rag,
    realm,
    reformer,
    regnet,
    rembert,
    resnet,
    roberta,
    roberta_prelayernorm,
    roc_bert,
    roformer,
    rwkv,
    sam,
    segformer,
    sew,
    sew_d,
    speech_encoder_decoder,
    speech_to_text,
    speech_to_text_a,
    speechta,
    splinter,
    squeezebert,
    swiftformer,
    swin,
    swinasr,
    swinva,
    switch_transformers,
    ta,
    table_transformer,
    tapas,
    time_series_transformer,
    timesformer,
    timm_backbone,
    transfo_xl,
    trocr,
    tvlt,
    umta,
    unispeech,
    unispeech_sat,
    upernet,
    videomae,
    vilt,
    vision_encoder_decoder,
    vision_text_dual_encoder,
    visual_bert,
    vit,
    vit_hybrid,
    vit_mae,
    vit_msn,
    vivit,
    wavaveca,
    wavaveca_conformer,
    wavaveca_phoneme,
    wavaveca_with_lm,
    wavlm,
    whisper,
    x_clip,
    xglm,
    xlm,
    xlm_prophetnet,
    xlm_roberta,
    xlm_roberta_xl,
    xlnet,
    xmod,
    yolos,
    yoso,
)








# 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


_snake_case      :							Optional[Any]     	=    logging.get_logger(__name__)





@dataclass
class   UpperCamelCase_      :







						'''simple docstring'''



						def __init__(			self							:str		,    lowerCAmelCase__							:Any=False		,    lowerCAmelCase__							:Tuple=False		,    lowerCAmelCase__							:List[str]=6.0		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Optional[Any]=False		,    lowerCAmelCase__							:List[Any]=False		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:Tuple="fp4"		,    lowerCAmelCase__							:Union[str, Any]=False		,    **lowerCAmelCase__							:Optional[Any]		,    )  ->Any:
										lowercase         =      load_in_abit
										lowercase         =      load_in_abit
										lowercase         =      llm_inta_threshold
										lowercase         =      llm_inta_skip_modules
										lowercase         =      llm_inta_enable_fpaa_cpu_offload
										lowercase         =      llm_inta_has_fpaa_weight
										lowercase         =      bnb_abit_quant_type
										lowercase         =      bnb_abit_use_double_quant

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

										self.post_init()





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->str:
										if not isinstance(self.llm_inta_threshold		,    lowerCAmelCase__     ):
														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		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_skip_modules must be a list of strings"     )
										if not isinstance(self.llm_inta_enable_fpaa_cpu_offload		,    lowerCAmelCase__     ):
														raise ValueError("llm_int8_enable_fp32_cpu_offload must be a boolean"     )

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

										if not isinstance(self.bnb_abit_use_double_quant		,    lowerCAmelCase__     ):
														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        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->Tuple:
										return self.load_in_abit or self.load_in_abit





						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->int:
										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        SCREAMING_SNAKE_CASE(			cls							:Union[str, Any]		,    lowerCAmelCase__							:List[Any]		,    lowerCAmelCase__							:Union[str, Any]		,    **lowerCAmelCase__							:Any     )  ->Optional[Any]:
										lowercase         =      cls(**lowerCAmelCase__     )

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

										if return_unused_kwargs:
														return config, kwargs
										else:
														return config





						def        SCREAMING_SNAKE_CASE(			self							:Dict		,    lowerCAmelCase__							:Union[str, os.PathLike]     )  ->Optional[int]:
										with open(lowerCAmelCase__		,    "w"		,    encoding="utf-8"     ) as writer:
														lowercase         =      self.to_dict()
														lowercase         =      json.dumps(lowerCAmelCase__		,    indent=2		,    sort_keys=lowerCAmelCase__     ) + "\n"

														writer.write(lowerCAmelCase__     )





						def        SCREAMING_SNAKE_CASE(			self							:Any     )  ->Dict[str, Any]:
										lowercase         =      copy.deepcopy(self.__dict__     )
										lowercase         =      str(output["bnb_4bit_compute_dtype"]     ).split("."     )[1]

										return output





						def __repr__(			self							:int     )  ->Optional[Any]:
										return F'''{self.__class__.__name__} {self.to_json_string()}'''





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:bool = True     )  ->str:
										if use_diff is True:
														lowercase         =      self.to_diff_dict()
										else:
														lowercase         =      self.to_dict()
										return json.dumps(lowerCAmelCase__		,    indent=2		,    sort_keys=lowerCAmelCase__     ) + "\n"





						def        SCREAMING_SNAKE_CASE(			self							:int     )  ->Dict[str, Any]:
										lowercase         =      self.to_dict()

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

										lowercase         =      {}

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

										return serializable_config_dict
