






'''simple docstring'''

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 							snake_case					(     a_							: dict	)       ->				tuple:





      """simple docstring"""

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



def 							snake_case					(     a_							: np.ndarray    ,   a_							: np.ndarray	)       ->				XGBClassifier:





      """simple docstring"""

      UpperCamelCase_				:   Optional[Any]					    =							XGBClassifier()
      classifier.fit(a_    ,   a_	)
      return classifier



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      UpperCamelCase_				:   int					    =							load_iris()
      UpperCamelCase_				:   Any					    =							data_handling(a_	)
      UpperCamelCase_				:   Optional[int]					    =							train_test_split(
          a_    ,   a_    ,   test_size=0.25	)

      UpperCamelCase_				:   str					    =							iris["""target_names"""]

      # Create an XGBoost Classifier from the training data
      UpperCamelCase_				:   Union[str, Any]					    =							xgboost(a_    ,   a_	)

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


if __name__ == "__main__":
      import doctest

      doctest.testmod(verbose=True)
      main()














'''simple docstring'''

import contextlib
import copy
import random
from typing import Any, Dict, Iterable, Optional, Union

import numpy as np
import torch

from .utils import deprecate, is_transformers_available


if is_transformers_available():
      import transformers



def 							snake_case					(     a_							: int	)       ->				Union[str, Any]:





      """simple docstring"""

      random.seed(a_	)
      np.random.seed(a_	)
      torch.manual_seed(a_	)
      torch.cuda.manual_seed_all(a_	)
      # ^^ safe to call this function even if cuda is not available




class     A    :






 """simple docstring"""





 def __init__(							self			,     __lowerCAmelCase			,     __lowerCAmelCase = 0.99_99			,     __lowerCAmelCase = 0.0			,     __lowerCAmelCase = 0			,     __lowerCAmelCase = False			,     __lowerCAmelCase = 1.0			,     __lowerCAmelCase = 2 / 3			,     __lowerCAmelCase = None			,     __lowerCAmelCase = None			,     **__lowerCAmelCase			,     ):

       if isinstance(__lowerCAmelCase			,     torch.nn.Module ):
             UpperCamelCase_				:   Dict					    =							(
                 """Passing a `torch.nn.Module` to `ExponentialMovingAverage` is deprecated. """
                 """Please pass the parameters of the module instead."""
             )
             deprecate(
                 """passing a `torch.nn.Module` to `ExponentialMovingAverage`"""			,     """1.0.0"""			,     __lowerCAmelCase			,     standard_warn=__lowerCAmelCase			,     )
             UpperCamelCase_				:   str					    =							parameters.parameters()

             # set use_ema_warmup to True if a torch.nn.Module is passed for backwards compatibility
             UpperCamelCase_				:   Optional[int]					    =							True

       if kwargs.get("""max_value"""			,     __lowerCAmelCase ) is not None:
             UpperCamelCase_				:   Tuple					    =							"""The `max_value` argument is deprecated. Please use `decay` instead."""
             deprecate("""max_value"""			,     """1.0.0"""			,     __lowerCAmelCase			,     standard_warn=__lowerCAmelCase )
             UpperCamelCase_				:   str					    =							kwargs["""max_value"""]

       if kwargs.get("""min_value"""			,     __lowerCAmelCase ) is not None:
             UpperCamelCase_				:   Dict					    =							"""The `min_value` argument is deprecated. Please use `min_decay` instead."""
             deprecate("""min_value"""			,     """1.0.0"""			,     __lowerCAmelCase			,     standard_warn=__lowerCAmelCase )
             UpperCamelCase_				:   Optional[Any]					    =							kwargs["""min_value"""]

       UpperCamelCase_				:   Optional[Any]					    =							list(__lowerCAmelCase )
       UpperCamelCase_				:   Any					    =							[p.clone().detach() for p in parameters]

       if kwargs.get("""device"""			,     __lowerCAmelCase ) is not None:
             UpperCamelCase_				:   str					    =							"""The `device` argument is deprecated. Please use `to` instead."""
             deprecate("""device"""			,     """1.0.0"""			,     __lowerCAmelCase			,     standard_warn=__lowerCAmelCase )
             self.to(device=kwargs["""device"""] )

       UpperCamelCase_				:   List[Any]					    =							None

       UpperCamelCase_				:   Optional[Any]					    =							decay
       UpperCamelCase_				:   List[str]					    =							min_decay
       UpperCamelCase_				:   int					    =							update_after_step
       UpperCamelCase_				:   Optional[int]					    =							use_ema_warmup
       UpperCamelCase_				:   Optional[int]					    =							inv_gamma
       UpperCamelCase_				:   Any					    =							power
       UpperCamelCase_				:   str					    =							0
       UpperCamelCase_				:   List[str]					    =							None  # set in `step()`

       UpperCamelCase_				:   Union[str, Any]					    =							model_cls
       UpperCamelCase_				:   Any					    =							model_config
 @classmethod
 def   _UpperCAmelCase       (							cls			,     __lowerCAmelCase			,     __lowerCAmelCase ):
       UpperCamelCase_    ,			UpperCamelCase_				:   int					    =							model_cls.load_config(__lowerCAmelCase			,     return_unused_kwargs=__lowerCAmelCase )
       UpperCamelCase_				:   str					    =							model_cls.from_pretrained(__lowerCAmelCase )

       UpperCamelCase_				:   Union[str, Any]					    =							cls(model.parameters()			,     model_cls=__lowerCAmelCase			,     model_config=model.config )

       ema_model.load_state_dict(__lowerCAmelCase )
       return ema_model
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       if self.model_cls is None:
             raise ValueError("""`save_pretrained` can only be used if `model_cls` was defined at __init__.""" )

       if self.model_config is None:
             raise ValueError("""`save_pretrained` can only be used if `model_config` was defined at __init__.""" )

       UpperCamelCase_				:   int					    =							self.model_cls.from_config(self.model_config )
       UpperCamelCase_				:   List[Any]					    =							self.state_dict()
       state_dict.pop("""shadow_params"""			,     __lowerCAmelCase )

       model.register_to_config(**__lowerCAmelCase )
       self.copy_to(model.parameters() )
       model.save_pretrained(__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       UpperCamelCase_				:   Any					    =							max(0			,     optimization_step - self.update_after_step - 1 )

       if step <= 0:
             return 0.0

       if self.use_ema_warmup:
             UpperCamelCase_				:   List[Any]					    =							1 - (1 + step / self.inv_gamma) ** -self.power
       else:
             UpperCamelCase_				:   List[Any]					    =							(1 + step) / (10 + step)

       UpperCamelCase_				:   Optional[Any]					    =							min(__lowerCAmelCase			,     self.decay )
       # make sure decay is not smaller than min_decay
       UpperCamelCase_				:   Optional[Any]					    =							max(__lowerCAmelCase			,     self.min_decay )
       return cur_decay_value
 @torch.no_grad()
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       if isinstance(__lowerCAmelCase			,     torch.nn.Module ):
             UpperCamelCase_				:   str					    =							(
                 """Passing a `torch.nn.Module` to `ExponentialMovingAverage.step` is deprecated. """
                 """Please pass the parameters of the module instead."""
             )
             deprecate(
                 """passing a `torch.nn.Module` to `ExponentialMovingAverage.step`"""			,     """1.0.0"""			,     __lowerCAmelCase			,     standard_warn=__lowerCAmelCase			,     )
             UpperCamelCase_				:   int					    =							parameters.parameters()

       UpperCamelCase_				:   Optional[int]					    =							list(__lowerCAmelCase )

       self.optimization_step += 1

       # Compute the decay factor for the exponential moving average.
       UpperCamelCase_				:   Any					    =							self.get_decay(self.optimization_step )
       UpperCamelCase_				:   List[str]					    =							decay
       UpperCamelCase_				:   Any					    =							1 - decay

       UpperCamelCase_				:   Optional[int]					    =							contextlib.nullcontext
       if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
             import deepspeed

       for s_param, param in zip(self.shadow_params			,     __lowerCAmelCase ):
             if is_transformers_available() and transformers.deepspeed.is_deepspeed_zeroa_enabled():
                   UpperCamelCase_				:   Optional[Any]					    =							deepspeed.zero.GatheredParameters(__lowerCAmelCase			,     modifier_rank=__lowerCAmelCase )

             with context_manager():
                   if param.requires_grad:
                         s_param.sub_(one_minus_decay * (s_param - param) )
                   else:
                         s_param.copy_(__lowerCAmelCase )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       UpperCamelCase_				:   str					    =							list(__lowerCAmelCase )
       for s_param, param in zip(self.shadow_params			,     __lowerCAmelCase ):
             param.data.copy_(s_param.to(param.device ).data )
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase=None			,     __lowerCAmelCase=None ):
       UpperCamelCase_				:   Union[str, Any]					    =							[
           p.to(device=__lowerCAmelCase			,     dtype=__lowerCAmelCase ) if p.is_floating_point() else p.to(device=__lowerCAmelCase )
           for p in self.shadow_params
       ]
 def   _UpperCAmelCase       (							self ):
       return {
           "decay": self.decay,
           "min_decay": self.min_decay,
           "optimization_step": self.optimization_step,
           "update_after_step": self.update_after_step,
           "use_ema_warmup": self.use_ema_warmup,
           "inv_gamma": self.inv_gamma,
           "power": self.power,
           "shadow_params": self.shadow_params,
       }
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       UpperCamelCase_				:   List[str]					    =							[param.detach().cpu().clone() for param in parameters]
 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       if self.temp_stored_params is None:
             raise RuntimeError("""This ExponentialMovingAverage has no `store()`ed weights """ """to `restore()`""" )
       for c_param, param in zip(self.temp_stored_params			,     __lowerCAmelCase ):
             param.data.copy_(c_param.data )

       # Better memory-wise.
       UpperCamelCase_				:   List[Any]					    =							None





 def   _UpperCAmelCase       (							self			,     __lowerCAmelCase ):
       UpperCamelCase_				:   List[Any]					    =							copy.deepcopy(__lowerCAmelCase )

       UpperCamelCase_				:   int					    =							state_dict.get("""decay"""			,     self.decay )
       if self.decay < 0.0 or self.decay > 1.0:
             raise ValueError("""Decay must be between 0 and 1""" )

       UpperCamelCase_				:   Dict					    =							state_dict.get("""min_decay"""			,     self.min_decay )
       if not isinstance(self.min_decay			,     __lowerCAmelCase ):
             raise ValueError("""Invalid min_decay""" )

       UpperCamelCase_				:   str					    =							state_dict.get("""optimization_step"""			,     self.optimization_step )
       if not isinstance(self.optimization_step			,     __lowerCAmelCase ):
             raise ValueError("""Invalid optimization_step""" )

       UpperCamelCase_				:   Dict					    =							state_dict.get("""update_after_step"""			,     self.update_after_step )
       if not isinstance(self.update_after_step			,     __lowerCAmelCase ):
             raise ValueError("""Invalid update_after_step""" )

       UpperCamelCase_				:   List[str]					    =							state_dict.get("""use_ema_warmup"""			,     self.use_ema_warmup )
       if not isinstance(self.use_ema_warmup			,     __lowerCAmelCase ):
             raise ValueError("""Invalid use_ema_warmup""" )

       UpperCamelCase_				:   Any					    =							state_dict.get("""inv_gamma"""			,     self.inv_gamma )
       if not isinstance(self.inv_gamma			,     (float, int) ):
             raise ValueError("""Invalid inv_gamma""" )

       UpperCamelCase_				:   str					    =							state_dict.get("""power"""			,     self.power )
       if not isinstance(self.power			,     (float, int) ):
             raise ValueError("""Invalid power""" )

       UpperCamelCase_				:   Dict					    =							state_dict.get("""shadow_params"""			,     __lowerCAmelCase )
       if shadow_params is not None:
             UpperCamelCase_				:   Any					    =							shadow_params
             if not isinstance(self.shadow_params			,     __lowerCAmelCase ):
                   raise ValueError("""shadow_params must be a list""" )
             if not all(isinstance(__lowerCAmelCase			,     torch.Tensor ) for p in self.shadow_params ):
                   raise ValueError("""shadow_params must all be Tensors""" )






