



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 	UpperCAmelCase__      (      UpperCAmelCase__ :dict					):






	'''simple docstring'''

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


def 	UpperCAmelCase__      (      UpperCAmelCase__ :np.ndarray ,					UpperCAmelCase__ :np.ndarray					):






	'''simple docstring'''

	a						=		XGBClassifier()
	classifier.fit(UpperCAmelCase__ ,					UpperCAmelCase__					)
	return classifier


def 	UpperCAmelCase__      (      ):






	'''simple docstring'''

	a						=		load_iris()
	a		,  a						=		data_handling(UpperCAmelCase__					)
	a		,  a		,  a		,  a						=		train_test_split(
	    UpperCAmelCase__ ,					UpperCAmelCase__ ,					test_size=0.25					)

	a						=		iris["target_names"]

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






import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
     import torch

     from transformers.generation import DisjunctiveConstraint



@require_torch
class 		_lowercase		(       unittest.TestCase	):

   def 		A							(      self			:       Union[str, Any]							)       ->				int:


    """simple docstring"""






    a						=		[[1, 2, 4], [1, 2, 3, 4]]
    a						=		DisjunctiveConstraint(__lowerCAmelCase							)
    self.assertTrue(isinstance(dc.token_ids							,   __lowerCAmelCase							)							)

    with self.assertRaises(__lowerCAmelCase							):
     DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]]							)							)

    with self.assertRaises(__lowerCAmelCase							):
     DisjunctiveConstraint([torch.LongTensor([1, 2, 4]							), torch.LongTensor([1, 2, 3, 4, 5]							)]							)

   def 		A							(      self			:       Tuple							)       ->				Dict:


    """simple docstring"""






    a						=		[[1, 2], [1, 2, 3, 4]]

    with self.assertRaises(__lowerCAmelCase							):
     DisjunctiveConstraint(__lowerCAmelCase							)  # fails here

   def 		A							(      self			:       int							)       ->				Any:


    """simple docstring"""






    a						=		[[1, 2, 3], [1, 2, 4]]

    a						=		DisjunctiveConstraint(__lowerCAmelCase							)

    a		,  a		,  a						=		dc.update(1							)
    a						=		stepped is True and completed is False and reset is False
    self.assertTrue(__lowerCAmelCase							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.current_seq == [1]							)

    a		,  a		,  a						=		dc.update(2							)
    a						=		stepped is True and completed is False and reset is False
    self.assertTrue(__lowerCAmelCase							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.current_seq == [1, 2]							)

    a		,  a		,  a						=		dc.update(3							)
    a						=		stepped is True and completed is True and reset is False
    self.assertTrue(__lowerCAmelCase							)
    self.assertTrue(dc.completed							)  # Completed!
    self.assertTrue(dc.current_seq == [1, 2, 3]							)




   def 		A							(      self			:       List[Any]							)       ->				List[Any]:


    """simple docstring"""






    a						=		[[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

    a						=		DisjunctiveConstraint(__lowerCAmelCase							)

    a		,  a		,  a						=		dc.update(1							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.current_seq == [1]							)

    a		,  a		,  a						=		dc.update(2							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.current_seq == [1, 2]							)

    a		,  a		,  a						=		dc.update(4							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.current_seq == [1, 2, 4]							)

    a		,  a		,  a						=		dc.update(5							)
    self.assertTrue(dc.completed							)  # Completed!
    self.assertTrue(dc.current_seq == [1, 2, 4, 5]							)

    dc.reset()

    a		,  a		,  a						=		dc.update(1							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.remaining() == 3							)
    self.assertTrue(dc.current_seq == [1]							)

    a		,  a		,  a						=		dc.update(2							)
    self.assertTrue(not dc.completed							)
    self.assertTrue(dc.remaining() == 2							)
    self.assertTrue(dc.current_seq == [1, 2]							)

    a		,  a		,  a						=		dc.update(5							)
    self.assertTrue(dc.completed							)  # Completed!
    self.assertTrue(dc.remaining() == 0							)
    self.assertTrue(dc.current_seq == [1, 2, 5]							)

