


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







def     lowerCamelCase( a__						,a__):
				_SCREAMING_SNAKE_CASE      	=XGBClassifier()
				classifier.fit(SCREAMING_SNAKE_CASE_						,SCREAMING_SNAKE_CASE_)
				return classifier







def     lowerCamelCase( ):
				_SCREAMING_SNAKE_CASE      	=load_iris()
				_SCREAMING_SNAKE_CASE	,					_SCREAMING_SNAKE_CASE      	=data_handling(SCREAMING_SNAKE_CASE_)
				_SCREAMING_SNAKE_CASE	,					_SCREAMING_SNAKE_CASE	,					_SCREAMING_SNAKE_CASE	,					_SCREAMING_SNAKE_CASE      	=train_test_split(
				    SCREAMING_SNAKE_CASE_						,SCREAMING_SNAKE_CASE_						,test_size=0.25)

				_SCREAMING_SNAKE_CASE      	=iris['''target_names''']

				# Create an XGBoost Classifier from the training data
				_SCREAMING_SNAKE_CASE      	=xgboost(SCREAMING_SNAKE_CASE_						,SCREAMING_SNAKE_CASE_)

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


if __name__ == "__main__":
							import doctest

							doctest.testmod(verbose=True)
							main()

def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# bit count represents no. of bits in the gray code
						if bit_count < 0:
												raise ValueError("""The given input must be positive"""       )

						# get the generated string sequence
						_lowercase					       =					gray_code_sequence_string(SCREAMING_SNAKE_CASE_       )
						#
						# convert them to integers
						for i in range(len(SCREAMING_SNAKE_CASE_       )       ):
												_lowercase					       =					int(sequence[i]		,   2       )

						return sequence




def 	UpperCamelCase__  (     SCREAMING_SNAKE_CASE_	:	int       )  ->     list:

						# The approach is a recursive one
						# Base case achieved when either n = 0 or n=1
						if bit_count == 0:
												return ["0"]

						if bit_count == 1:
												return ["0", "1"]

						_lowercase					       =					1 << bit_count  # defines the length of the sequence
						# 1<< n is equivalent to 2^n

						# recursive answer will generate answer for n-1 bits
						_lowercase					       =					gray_code_sequence_string(bit_count - 1       )

						_lowercase					       =					[]

						# append 0 to first half of the smaller sequence generated
						for i in range(seq_len // 2       ):
												_lowercase					       =					"""0""" + smaller_sequence[i]
												sequence.append(SCREAMING_SNAKE_CASE_       )

						# append 1 to second half ... start from the end of the list
						for i in reversed(range(seq_len // 2       )       ):
												_lowercase					       =					"""1""" + smaller_sequence[i]
												sequence.append(SCREAMING_SNAKE_CASE_       )

						return sequence


if __name__ == "__main__":
		import doctest

		doctest.testmod()