



# 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 torch

from ..models.auto import AutoModelForSequenceClassification, AutoTokenizer
from .base import PipelineTool



class     _UpperCAmelCase			(       A__     ):
     UpperCamelCase__		    =				'''facebook/bart-large-mnli'''
     UpperCamelCase__		    =				(
         '''This is a tool that classifies an English text using provided labels. It takes two inputs: `text`, which '''
         '''should be the text to classify, and `labels`, which should be the list of labels to use for classification. '''
         '''It returns the most likely label in the list of provided `labels` for the input text.'''
     )
     UpperCamelCase__		    =				'''text_classifier'''
     UpperCamelCase__		    =				AutoTokenizer
     UpperCamelCase__		    =				AutoModelForSequenceClassification

     UpperCamelCase__		    =				['''text''', ['''text''']]
     UpperCamelCase__		    =				['''text''']




     def 		snake_case_		(				self):
         super().setup()
         A__		 =					self.model.config
         A__		 =					-1
         for idx, label in config.idalabel.items():
             if label.lower().startswith('''entail'''):
                 A__		 =					int(a__)
         if self.entailment_id == -1:
             raise ValueError('''Could not determine the entailment ID from the model config, please pass it at init.''')




     def 		snake_case_		(				self ,						a__ ,						a__):
         A__		 =					labels
         return self.pre_processor(
             [text] * len(a__) ,						[F"This example is {label}" for label in labels] ,						return_tensors='''pt''' ,						padding='''max_length''' ,						)




     def 		snake_case_		(				self ,						a__):
         A__		 =					outputs.logits
         A__		 =					torch.argmax(logits[:, 2]).item()
         return self._labels[label_id]





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:
    A__		 =					XGBClassifier()
    classifier.fit(UpperCamelCase_ ,       UpperCamelCase_	)
    return classifier



def 		lowerCAmelCase__    (					)->  None:
    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()
