





# 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  __lowerCAmelCase	:






			def __init__(self ,							__magic_name__=False ,							__magic_name__=False ,							__magic_name__=6.0 ,							__magic_name__=None ,							__magic_name__=False ,							__magic_name__=False ,							__magic_name__=None ,							__magic_name__="fp4" ,							__magic_name__=False ,							**__magic_name__ ,							)					->       str:


							'''simple docstring'''



							snake_case_						:   Dict           =  load_in_abit
							snake_case_						:   int           =  load_in_abit
							snake_case_						:   int           =  llm_inta_threshold
							snake_case_						:   Any           =  llm_inta_skip_modules
							snake_case_						:   Dict           =  llm_inta_enable_fpaa_cpu_offload
							snake_case_						:   Optional[Any]           =  llm_inta_has_fpaa_weight
							snake_case_						:   Optional[int]           =  bnb_abit_quant_type
							snake_case_						:   Union[str, Any]           =  bnb_abit_use_double_quant

							if bnb_abit_compute_dtype is None:
											snake_case_						:   int           =  torch.floataa
							elif isinstance(__magic_name__ ,							__magic_name__   ):
											snake_case_						:   Any           =  getattr(__magic_name__ ,							__magic_name__   )
							elif isinstance(__magic_name__ ,							torch.dtype   ):
											snake_case_						:   str           =  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   )					->       List[Any]:


							'''simple docstring'''



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

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

							if not isinstance(self.bnb_abit_use_double_quant ,							__magic_name__   ):
											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   )					->       Optional[int]:


							'''simple docstring'''



							return self.load_in_abit or self.load_in_abit






			def       lowerCamelCase  (self   )					->       Optional[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       lowerCamelCase  (cls ,							__magic_name__ ,							__magic_name__ ,							**__magic_name__   )					->       Any:


							'''simple docstring'''



							snake_case_						:   int           =  cls(**__magic_name__   )

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

							if return_unused_kwargs:
											return config, kwargs
							else:
											return config






			def       lowerCamelCase  (self ,							__magic_name__   )					->       List[str]:


							'''simple docstring'''



							with open(__magic_name__ ,							'''w''' ,							encoding='''utf-8'''   ) as writer:
											snake_case_						:   str           =  self.to_dict()
											snake_case_						:   Tuple           =  json.dumps(__magic_name__ ,							indent=2 ,							sort_keys=__magic_name__   ) + '''\n'''

											writer.write(__magic_name__   )






			def       lowerCamelCase  (self   )					->       Dict[str, Any]:


							'''simple docstring'''



							snake_case_						:   Optional[Any]           =  copy.deepcopy(self.__dict__   )
							snake_case_						:   List[Any]           =  str(output['''bnb_4bit_compute_dtype''']   ).split('''.'''   )[1]

							return output






			def __repr__(self   )					->       List[str]:


							'''simple docstring'''



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






			def       lowerCamelCase  (self ,							__magic_name__ = True   )					->       str:


							'''simple docstring'''



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






			def       lowerCamelCase  (self   )					->       Dict[str, Any]:


							'''simple docstring'''



							snake_case_						:   List[str]           =  self.to_dict()

							# get the default config dict
							snake_case_						:   Union[str, Any]           =  BitsAndBytesConfig().to_dict()

							snake_case_						:   Union[str, Any]           =  {}

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

							return serializable_config_dict







import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier






def 					lowerCamelCase_						(    _UpperCamelCase			)		->						tuple:






				"""simple docstring"""


				return (data["data"], data["target"])






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			)		->						XGBClassifier:






				"""simple docstring"""


				snake_case_						:   Optional[Any]           =  XGBClassifier()
				classifier.fit(_UpperCamelCase			,    _UpperCamelCase			)
				return classifier






def 					lowerCamelCase_						(    )		->						None:






				"""simple docstring"""


				snake_case_						:   Optional[Any]           =  load_iris()
				snake_case_      ,							snake_case_						:   str           =  data_handling(_UpperCamelCase			)
				snake_case_      ,							snake_case_      ,							snake_case_      ,							snake_case_						:   Dict           =  train_test_split(
				    _UpperCamelCase			,    _UpperCamelCase			,    test_size=0.25			)

				snake_case_						:   List[str]           =  iris['''target_names''']

				# Create an XGBoost Classifier from the training data
				snake_case_						:   int           =  xgboost(_UpperCamelCase			,    _UpperCamelCase			)

				# Display the confusion matrix of the classifier with both training and test sets
				ConfusionMatrixDisplay.from_estimator(
				    _UpperCamelCase			,    _UpperCamelCase			,    _UpperCamelCase			,    display_labels=_UpperCamelCase			,    cmap='''Blues'''			,    normalize='''true'''			,    )
				plt.title('''Normalized Confusion Matrix - IRIS Dataset'''			)
				plt.show()


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()
