
import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test





class       __A(				unittest.TestCase       ):

					@parameterized.expand([(None,), ("""foo.json""",)]   )
					def    lowercase__      (	self					:     Any   ,					__UpperCamelCase					:     Union[str, Any]   ):
												lowerCamelCase_							  =					GenerationConfig(
												    do_sample=__UpperCamelCase   ,					temperature=0.7   ,					length_penalty=1.0   ,					bad_words_ids=[[1, 2, 3], [4, 5]]   ,					)
												with tempfile.TemporaryDirectory() as tmp_dir:
																			config.save_pretrained(__UpperCamelCase   ,					config_name=__UpperCamelCase   )
																			lowerCamelCase_							  =					GenerationConfig.from_pretrained(__UpperCamelCase   ,					config_name=__UpperCamelCase   )

												# Checks parameters that were specified
												self.assertEqual(loaded_config.do_sample   ,					__UpperCamelCase   )
												self.assertEqual(loaded_config.temperature   ,					0.7   )
												self.assertEqual(loaded_config.length_penalty   ,					1.0   )
												self.assertEqual(loaded_config.bad_words_ids   ,					[[1, 2, 3], [4, 5]]   )

												# Checks parameters that were not specified (defaults)
												self.assertEqual(loaded_config.top_k   ,					5_0   )
												self.assertEqual(loaded_config.max_length   ,					2_0   )
												self.assertEqual(loaded_config.max_time   ,					__UpperCamelCase   )

					def    lowercase__      (	self					:     List[Any]   ):
												lowerCamelCase_							  =					AutoConfig.from_pretrained("""gpt2"""   )
												lowerCamelCase_							  =					GenerationConfig.from_model_config(__UpperCamelCase   )
												lowerCamelCase_							  =					GenerationConfig()

												# The generation config has loaded a few non-default parameters from the model config
												self.assertNotEqual(__UpperCamelCase   ,					__UpperCamelCase   )

												# One of those parameters is eos_token_id -- check if it matches
												self.assertNotEqual(generation_config_from_model.eos_token_id   ,					default_generation_config.eos_token_id   )
												self.assertEqual(generation_config_from_model.eos_token_id   ,					model_config.eos_token_id   )

					def    lowercase__      (	self					:     Optional[Any]   ):
												lowerCamelCase_							  =					GenerationConfig()
												lowerCamelCase_							  =					{
												    """max_new_tokens""": 1_0_2_4,
												    """foo""": """bar""",
												}
												lowerCamelCase_							  =					copy.deepcopy(__UpperCamelCase   )
												lowerCamelCase_							  =					generation_config.update(**__UpperCamelCase   )

												# update_kwargs was not modified (no side effects)
												self.assertEqual(__UpperCamelCase   ,					__UpperCamelCase   )

												# update_kwargs was used to update the config on valid attributes
												self.assertEqual(generation_config.max_new_tokens   ,					1_0_2_4   )

												# `.update()` returns a dictionary of unused kwargs
												self.assertEqual(__UpperCamelCase   ,					{"""foo""": """bar"""}   )

					def    lowercase__      (	self					:     Optional[Any]   ):
												lowerCamelCase_							  =					GenerationConfig()
												lowerCamelCase_							  =					"""bar"""

												with tempfile.TemporaryDirectory("""test-generation-config"""   ) as tmp_dir:
																			generation_config.save_pretrained(__UpperCamelCase   )

																			lowerCamelCase_							  =					GenerationConfig.from_pretrained(__UpperCamelCase   )
												# update_kwargs was used to update the config on valid attributes
												self.assertEqual(new_config.foo   ,					"""bar"""   )

												lowerCamelCase_							  =					GenerationConfig.from_model_config(__UpperCamelCase   )
												assert not hasattr(__UpperCamelCase   ,					"""foo"""   )  # no new kwargs should be initialized if from config



					def    lowercase__      (	self					:     str   ):
												lowerCamelCase_							  =					GenerationConfig()
												self.assertEqual(default_config.temperature   ,					1.0   )
												self.assertEqual(default_config.do_sample   ,					__UpperCamelCase   )
												self.assertEqual(default_config.num_beams   ,					1   )

												lowerCamelCase_							  =					GenerationConfig(
												    do_sample=__UpperCamelCase   ,					temperature=0.7   ,					length_penalty=1.0   ,					bad_words_ids=[[1, 2, 3], [4, 5]]   ,					)
												self.assertEqual(config.temperature   ,					0.7   )
												self.assertEqual(config.do_sample   ,					__UpperCamelCase   )
												self.assertEqual(config.num_beams   ,					1   )

												with tempfile.TemporaryDirectory() as tmp_dir:
																			config.save_pretrained(__UpperCamelCase   )
																			lowerCamelCase_							  =					GenerationConfig.from_pretrained(__UpperCamelCase   ,					temperature=1.0   )

												self.assertEqual(loaded_config.temperature   ,					1.0   )
												self.assertEqual(loaded_config.do_sample   ,					__UpperCamelCase   )
												self.assertEqual(loaded_config.num_beams   ,					1   )  # default value





@is_staging_test
class       __A(				unittest.TestCase       ):

					@classmethod
					def    lowercase__      (	cls					:     Union[str, Any]   ):
												lowerCamelCase_							  =					TOKEN
												HfFolder.save_token(__UpperCamelCase   )

					@classmethod
					def    lowercase__      (	cls					:     Dict   ):
												try:
																			delete_repo(token=cls._token   ,					repo_id="""test-generation-config"""   )
												except HTTPError:
																			pass

												try:
																			delete_repo(token=cls._token   ,					repo_id="""valid_org/test-generation-config-org"""   )
												except HTTPError:
																			pass

					def    lowercase__      (	self					:     List[Any]   ):
												lowerCamelCase_							  =					GenerationConfig(
												    do_sample=__UpperCamelCase   ,					temperature=0.7   ,					length_penalty=1.0   ,					)
												config.push_to_hub("""test-generation-config"""   ,					use_auth_token=self._token   )

												lowerCamelCase_							  =					GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''   )
												for k, v in config.to_dict().items():
																			if k != "transformers_version":
																										self.assertEqual(__UpperCamelCase   ,					getattr(__UpperCamelCase   ,					__UpperCamelCase   )   )

        # Reset repo
												delete_repo(token=self._token   ,					repo_id="""test-generation-config"""   )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																			config.save_pretrained(
																			    __UpperCamelCase   ,					repo_id="""test-generation-config"""   ,					push_to_hub=__UpperCamelCase   ,					use_auth_token=self._token   )

												lowerCamelCase_							  =					GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''   )
												for k, v in config.to_dict().items():
																			if k != "transformers_version":
																										self.assertEqual(__UpperCamelCase   ,					getattr(__UpperCamelCase   ,					__UpperCamelCase   )   )



					def    lowercase__      (	self					:     Tuple   ):
												lowerCamelCase_							  =					GenerationConfig(
												    do_sample=__UpperCamelCase   ,					temperature=0.7   ,					length_penalty=1.0   ,					)
												config.push_to_hub("""valid_org/test-generation-config-org"""   ,					use_auth_token=self._token   )

												lowerCamelCase_							  =					GenerationConfig.from_pretrained("""valid_org/test-generation-config-org"""   )
												for k, v in config.to_dict().items():
																			if k != "transformers_version":
																										self.assertEqual(__UpperCamelCase   ,					getattr(__UpperCamelCase   ,					__UpperCamelCase   )   )

        # Reset repo
												delete_repo(token=self._token   ,					repo_id="""valid_org/test-generation-config-org"""   )

												# Push to hub via save_pretrained
												with tempfile.TemporaryDirectory() as tmp_dir:
																			config.save_pretrained(
																			    __UpperCamelCase   ,					repo_id="""valid_org/test-generation-config-org"""   ,					push_to_hub=__UpperCamelCase   ,					use_auth_token=self._token   )

												lowerCamelCase_							  =					GenerationConfig.from_pretrained("""valid_org/test-generation-config-org"""   )
												for k, v in config.to_dict().items():
																			if k != "transformers_version":
																										self.assertEqual(__UpperCamelCase   ,					getattr(__UpperCamelCase   ,					__UpperCamelCase   )   )







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__				:      dict       )  ->    tuple:
							return (data["data"], data["target"])



def      __lowerCAmelCase						(							UpperCAmelCase__				:      np.ndarray			,				UpperCAmelCase__				:      np.ndarray       )  ->    XGBClassifier:
							lowerCamelCase_							  =					XGBClassifier()
							classifier.fit(UpperCAmelCase__			,				UpperCAmelCase__       )
							return classifier



def      __lowerCAmelCase						(							)  ->    None:
							lowerCamelCase_							  =					load_iris()
							lowerCamelCase_  ,   lowerCamelCase_							  =					data_handling(UpperCAmelCase__       )
							lowerCamelCase_  ,   lowerCamelCase_  ,   lowerCamelCase_  ,   lowerCamelCase_							  =					train_test_split(
							    UpperCAmelCase__			,				UpperCAmelCase__			,				test_size=0.2_5       )

							lowerCamelCase_							  =					iris["""target_names"""]

							# Create an XGBoost Classifier from the training data
							lowerCamelCase_							  =					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()





