



"""simple docstring"""
from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


A:   Tuple								=		logging.get_logger(__name__)

A:   List[Any]								=		{
    "facebook/blenderbot_small-90M": "https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json",
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   int						=						'blenderbot-small'
   __lowerCAmelCase  :   Any						=						['past_key_values']
   __lowerCAmelCase  :   str						=						{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE=50265      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=8      ,     _SCREAMING_SNAKE_CASE=2048      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=8      ,     _SCREAMING_SNAKE_CASE=2048      ,     _SCREAMING_SNAKE_CASE=16      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE="gelu"      ,     _SCREAMING_SNAKE_CASE=512      ,     _SCREAMING_SNAKE_CASE=0.1      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=0.02      ,     _SCREAMING_SNAKE_CASE=1      ,     _SCREAMING_SNAKE_CASE=False      ,     _SCREAMING_SNAKE_CASE=0      ,     _SCREAMING_SNAKE_CASE=1      ,     _SCREAMING_SNAKE_CASE=2      ,     _SCREAMING_SNAKE_CASE=2      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      str:





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	vocab_size
    UpperCAmelCase	:					Any	=	max_position_embeddings
    UpperCAmelCase	:					str	=	d_model
    UpperCAmelCase	:					List[Any]	=	encoder_ffn_dim
    UpperCAmelCase	:					Union[str, Any]	=	encoder_layers
    UpperCAmelCase	:					List[str]	=	encoder_attention_heads
    UpperCAmelCase	:					Optional[Any]	=	decoder_ffn_dim
    UpperCAmelCase	:					List[Any]	=	decoder_layers
    UpperCAmelCase	:					Any	=	decoder_attention_heads
    UpperCAmelCase	:					Union[str, Any]	=	dropout
    UpperCAmelCase	:					Union[str, Any]	=	attention_dropout
    UpperCAmelCase	:					int	=	activation_dropout
    UpperCAmelCase	:					int	=	activation_function
    UpperCAmelCase	:					Optional[Any]	=	init_std
    UpperCAmelCase	:					List[str]	=	encoder_layerdrop
    UpperCAmelCase	:					List[str]	=	decoder_layerdrop
    UpperCAmelCase	:					List[str]	=	use_cache
    UpperCAmelCase	:					Union[str, Any]	=	encoder_layers
    UpperCAmelCase	:					Any	=	scale_embedding  # scale factor will be sqrt(d_model) if True

    super().__init__(
        pad_token_id=_SCREAMING_SNAKE_CASE      ,     bos_token_id=_SCREAMING_SNAKE_CASE      ,     eos_token_id=_SCREAMING_SNAKE_CASE      ,     is_encoder_decoder=_SCREAMING_SNAKE_CASE      ,     decoder_start_token_id=_SCREAMING_SNAKE_CASE      ,     forced_eos_token_id=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE      ,     )



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Mapping[str, Mapping[int, str]]:





    '''simple docstring'''




    if self.task in ["default", "seq2seq-lm"]:
     UpperCAmelCase	:					Dict	=	OrderedDict(
         [
             ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
             ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
         ]						)

     if self.use_past:
      UpperCAmelCase	:					int	=	{0: """batch"""}
      UpperCAmelCase	:					List[Any]	=	{0: """batch""", 1: """past_decoder_sequence + sequence"""}
     else:
      UpperCAmelCase	:					Optional[Any]	=	{0: """batch""", 1: """decoder_sequence"""}
      UpperCAmelCase	:					Any	=	{0: """batch""", 1: """decoder_sequence"""}

     if self.use_past:
      self.fill_with_past_key_values_(_SCREAMING_SNAKE_CASE      ,     direction="""inputs"""						)
    elif self.task == "causal-lm":
     # TODO: figure this case out.
     UpperCAmelCase	:					int	=	OrderedDict(
         [
             ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
             ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
         ]						)
     if self.use_past:
      UpperCAmelCase	,		UpperCAmelCase	:					Tuple	=	self.num_layers
      for i in range(_SCREAMING_SNAKE_CASE						):
       UpperCAmelCase	:					Optional[Any]	=	{0: """batch""", 2: """past_sequence + sequence"""}
       UpperCAmelCase	:					List[Any]	=	{0: """batch""", 2: """past_sequence + sequence"""}
    else:
     UpperCAmelCase	:					Dict	=	OrderedDict(
         [
             ("""input_ids""", {0: """batch""", 1: """encoder_sequence"""}),
             ("""attention_mask""", {0: """batch""", 1: """encoder_sequence"""}),
             ("""decoder_input_ids""", {0: """batch""", 1: """decoder_sequence"""}),
             ("""decoder_attention_mask""", {0: """batch""", 1: """decoder_sequence"""}),
         ]						)

    return common_inputs

   @property
   def 	SCREAMING_SNAKE_CASE     (   self						)  ->      Mapping[str, Mapping[int, str]]:





    '''simple docstring'''




    if self.task in ["default", "seq2seq-lm"]:
     UpperCAmelCase	:					Union[str, Any]	=	super().outputs
    else:
     UpperCAmelCase	:					int	=	super(_SCREAMING_SNAKE_CASE      ,     self						).outputs
     if self.use_past:
      UpperCAmelCase	,		UpperCAmelCase	:					Any	=	self.num_layers
      for i in range(_SCREAMING_SNAKE_CASE						):
       UpperCAmelCase	:					List[str]	=	{0: """batch""", 2: """past_sequence + sequence"""}
       UpperCAmelCase	:					List[str]	=	{0: """batch""", 2: """past_sequence + sequence"""}
    return common_outputs

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     )  ->      Mapping[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Dict	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    # Generate decoder inputs
    UpperCAmelCase	:					Optional[Any]	=	seq_length if not self.use_past else 1
    UpperCAmelCase	:					Dict	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Any	=	{F"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
    UpperCAmelCase	:					Union[str, Any]	=	dict(**_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)

    if self.use_past:
     if not is_torch_available():
      raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""						)
     else:
      import torch
     UpperCAmelCase	,		UpperCAmelCase	:					int	=	common_inputs["""input_ids"""].shape
     UpperCAmelCase	:					Any	=	common_inputs["""decoder_input_ids"""].shape[1]
     UpperCAmelCase	,		UpperCAmelCase	:					str	=	self.num_attention_heads
     UpperCAmelCase	:					Union[str, Any]	=	(
         batch,
         num_encoder_attention_heads,
         encoder_seq_length,
         self._config.hidden_size // num_encoder_attention_heads,
     )
     UpperCAmelCase	:					Union[str, Any]	=	decoder_seq_length + 3
     UpperCAmelCase	:					Union[str, Any]	=	(
         batch,
         num_decoder_attention_heads,
         decoder_past_length,
         self._config.hidden_size // num_decoder_attention_heads,
     )

     UpperCAmelCase	:					Optional[Any]	=	torch.cat(
         [common_inputs["""decoder_attention_mask"""], torch.ones(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)]      ,     dim=1						)

     UpperCAmelCase	:					List[str]	=	[]
     # If the number of encoder and decoder layers are present in the model configuration, both are considered
     UpperCAmelCase	,		UpperCAmelCase	:					List[Any]	=	self.num_layers
     UpperCAmelCase	:					Optional[Any]	=	min(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
     UpperCAmelCase	:					Optional[Any]	=	max(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						) - min_num_layers
     UpperCAmelCase	:					Optional[int]	=	"""encoder""" if num_encoder_layers > num_decoder_layers else """decoder"""

     for _ in range(_SCREAMING_SNAKE_CASE						):
      common_inputs["past_key_values"].append(
          (
              torch.zeros(_SCREAMING_SNAKE_CASE						),
              torch.zeros(_SCREAMING_SNAKE_CASE						),
              torch.zeros(_SCREAMING_SNAKE_CASE						),
              torch.zeros(_SCREAMING_SNAKE_CASE						),
          )						)
     # TODO: test this.
     UpperCAmelCase	:					Dict	=	encoder_shape if remaining_side_name == """encoder""" else decoder_shape
     for _ in range(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						):
      common_inputs["past_key_values"].append((torch.zeros(_SCREAMING_SNAKE_CASE						), torch.zeros(_SCREAMING_SNAKE_CASE						))						)
    return common_inputs

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     )  ->      Mapping[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					Tuple	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
        _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    if self.use_past:
     if not is_torch_available():
      raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""						)
     else:
      import torch
     UpperCAmelCase	,		UpperCAmelCase	:					Optional[Any]	=	common_inputs["""input_ids"""].shape
     # Not using the same length for past_key_values
     UpperCAmelCase	:					Union[str, Any]	=	seqlen + 2
     UpperCAmelCase	,		UpperCAmelCase	:					Optional[int]	=	self.num_layers
     UpperCAmelCase	,		UpperCAmelCase	:					Dict	=	self.num_attention_heads
     UpperCAmelCase	:					Any	=	(
         batch,
         num_encoder_attention_heads,
         past_key_values_length,
         self._config.hidden_size // num_encoder_attention_heads,
     )

     UpperCAmelCase	:					List[Any]	=	common_inputs["""attention_mask"""].dtype
     UpperCAmelCase	:					Any	=	torch.cat(
         [common_inputs["""attention_mask"""], torch.ones(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     dtype=_SCREAMING_SNAKE_CASE						)]      ,     dim=1						)
     UpperCAmelCase	:					List[str]	=	[
         (torch.zeros(_SCREAMING_SNAKE_CASE						), torch.zeros(_SCREAMING_SNAKE_CASE						)) for _ in range(_SCREAMING_SNAKE_CASE						)
     ]
    return common_inputs

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     )  ->      Mapping[str, Any]:





    '''simple docstring'''




    UpperCAmelCase	:					str	=	compute_effective_axis_dimension(
        _SCREAMING_SNAKE_CASE      ,     fixed_dimension=OnnxConfig.default_fixed_batch      ,     num_token_to_add=0						)

    # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
    UpperCAmelCase	:					List[str]	=	tokenizer.num_special_tokens_to_add(_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					int	=	compute_effective_axis_dimension(
        _SCREAMING_SNAKE_CASE      ,     fixed_dimension=OnnxConfig.default_fixed_sequence      ,     num_token_to_add=_SCREAMING_SNAKE_CASE						)

    # Generate dummy inputs according to compute batch and sequence
    UpperCAmelCase	:					Dict	=	[""" """.join([tokenizer.unk_token]						) * seq_length] * batch_size
    UpperCAmelCase	:					Optional[int]	=	dict(tokenizer(_SCREAMING_SNAKE_CASE      ,     return_tensors=_SCREAMING_SNAKE_CASE						)						)
    return common_inputs

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = -1      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     )  ->      Mapping[str, Any]:





    '''simple docstring'''




    if self.task in ["default", "seq2seq-lm"]:
     UpperCAmelCase	:					Optional[int]	=	self._generate_dummy_inputs_for_default_and_seqaseq_lm(
         _SCREAMING_SNAKE_CASE      ,     batch_size=_SCREAMING_SNAKE_CASE      ,     seq_length=_SCREAMING_SNAKE_CASE      ,     is_pair=_SCREAMING_SNAKE_CASE      ,     framework=_SCREAMING_SNAKE_CASE						)

    elif self.task == "causal-lm":
     UpperCAmelCase	:					Optional[int]	=	self._generate_dummy_inputs_for_causal_lm(
         _SCREAMING_SNAKE_CASE      ,     batch_size=_SCREAMING_SNAKE_CASE      ,     seq_length=_SCREAMING_SNAKE_CASE      ,     is_pair=_SCREAMING_SNAKE_CASE      ,     framework=_SCREAMING_SNAKE_CASE						)
    else:
     UpperCAmelCase	:					Tuple	=	self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
         _SCREAMING_SNAKE_CASE      ,     batch_size=_SCREAMING_SNAKE_CASE      ,     seq_length=_SCREAMING_SNAKE_CASE      ,     is_pair=_SCREAMING_SNAKE_CASE      ,     framework=_SCREAMING_SNAKE_CASE						)

    return common_inputs




   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)  ->      List[Any]:





    '''simple docstring'''




    if self.task in ["default", "seq2seq-lm"]:
     UpperCAmelCase	:					List[Any]	=	super()._flatten_past_key_values_(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    else:
     UpperCAmelCase	:					Dict	=	super(_SCREAMING_SNAKE_CASE      ,     self						)._flatten_past_key_values_(
         _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)


import shutil
import tempfile
import unittest
from unittest.mock import patch

from transformers import (
    DefaultFlowCallback,
    IntervalStrategy,
    PrinterCallback,
    ProgressCallback,
    Trainer,
    TrainerCallback,
    TrainingArguments,
    is_torch_available,
)
from transformers.testing_utils import require_torch


if is_torch_available():
					from transformers.trainer import DEFAULT_CALLBACKS

					from .test_trainer import RegressionDataset, RegressionModelConfig, RegressionPreTrainedModel

class    lowerCAmelCase__     (	__lowercase			):






		def __init__(		self		:							int  )     ->							Optional[int]:
						__lowerCamelCase    					=	[]






		def  __A       (		self		:							Any							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							str							,			**SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							Tuple:
						self.events.append('''on_init_end'''  )






		def  __A       (		self		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			**SCREAMING_SNAKE_CASE__		:							Optional[Any]  )     ->							Any:
						self.events.append('''on_train_begin'''  )






		def  __A       (		self		:							str							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							Dict							,			**SCREAMING_SNAKE_CASE__		:							int  )     ->							Any:
						self.events.append('''on_train_end'''  )






		def  __A       (		self		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			**SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							int:
						self.events.append('''on_epoch_begin'''  )






		def  __A       (		self		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Any							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]							,			**SCREAMING_SNAKE_CASE__		:							Tuple  )     ->							Optional[Any]:
						self.events.append('''on_epoch_end'''  )






		def  __A       (		self		:							str							,			SCREAMING_SNAKE_CASE__		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							Optional[Any]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			**SCREAMING_SNAKE_CASE__		:							str  )     ->							List[Any]:
						self.events.append('''on_step_begin'''  )






		def  __A       (		self		:							Any							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							Any							,			**SCREAMING_SNAKE_CASE__		:							Optional[int]  )     ->							Tuple:
						self.events.append('''on_step_end'''  )






		def  __A       (		self		:							int							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							int							,			**SCREAMING_SNAKE_CASE__		:							List[Any]  )     ->							Union[str, Any]:
						self.events.append('''on_evaluate'''  )






		def  __A       (		self		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							str							,			**SCREAMING_SNAKE_CASE__		:							str  )     ->							str:
						self.events.append('''on_predict'''  )






		def  __A       (		self		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							int							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							Optional[int]							,			**SCREAMING_SNAKE_CASE__		:							Optional[Any]  )     ->							Tuple:
						self.events.append('''on_save'''  )






		def  __A       (		self		:							Optional[int]							,			SCREAMING_SNAKE_CASE__		:							Dict							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							Union[str, Any]							,			**SCREAMING_SNAKE_CASE__		:							List[str]  )     ->							List[str]:
						self.events.append('''on_log'''  )







		def  __A       (		self		:							int							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							List[Any]							,			**SCREAMING_SNAKE_CASE__		:							Optional[int]  )     ->							str:
						self.events.append('''on_prediction_step'''  )





@require_torch
class    lowerCAmelCase__     (	unittest.TestCase			):






		def  __A       (		self		:							Union[str, Any]  )     ->							Optional[Any]:
						__lowerCamelCase    					=	tempfile.mkdtemp()






		def  __A       (		self		:							int  )     ->							List[str]:
						shutil.rmtree(self.output_dir  )






		def  __A       (		self		:							Tuple							,			SCREAMING_SNAKE_CASE__		:							List[Any]=0							,			SCREAMING_SNAKE_CASE__		:							Any=0							,			SCREAMING_SNAKE_CASE__		:							List[str]=64							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=64							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=None							,			SCREAMING_SNAKE_CASE__		:							Optional[int]=False							,			**SCREAMING_SNAKE_CASE__		:							Optional[Any]  )     ->							Union[str, Any]:
						# disable_tqdm in TrainingArguments has a flaky default since it depends on the level of logging. We make sure
						# its set to False since the tests later on depend on its value.
						__lowerCamelCase    					=	RegressionDataset(length=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	RegressionDataset(length=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	RegressionModelConfig(a=SCREAMING_SNAKE_CASE__							,			b=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	RegressionPreTrainedModel(SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	TrainingArguments(self.output_dir							,			disable_tqdm=SCREAMING_SNAKE_CASE__							,			report_to=[]							,			**SCREAMING_SNAKE_CASE__  )
						return Trainer(
						    SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__							,			train_dataset=SCREAMING_SNAKE_CASE__							,			eval_dataset=SCREAMING_SNAKE_CASE__							,			callbacks=SCREAMING_SNAKE_CASE__							,			)






		def  __A       (		self		:							List[Any]							,			SCREAMING_SNAKE_CASE__		:							List[str]							,			SCREAMING_SNAKE_CASE__		:							str  )     ->							Optional[int]:
						self.assertEqual(len(SCREAMING_SNAKE_CASE__  )							,			len(SCREAMING_SNAKE_CASE__  )  )

						# Order doesn't matter
						__lowerCamelCase    					=	sorted(SCREAMING_SNAKE_CASE__							,			key=lambda SCREAMING_SNAKE_CASE__  : cb.__name__ if isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) else cb.__class__.__name__  )
						__lowerCamelCase    					=	sorted(SCREAMING_SNAKE_CASE__							,			key=lambda SCREAMING_SNAKE_CASE__  : cb.__name__ if isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) else cb.__class__.__name__  )

						for cba, cba in zip(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ):
										if isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) and isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ):
														self.assertEqual(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )
										elif isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) and not isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ):
														self.assertEqual(SCREAMING_SNAKE_CASE__							,			cba.__class__  )
										elif not isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ) and isinstance(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  ):
														self.assertEqual(cba.__class__							,			SCREAMING_SNAKE_CASE__  )
										else:
														self.assertEqual(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							Union[str, Any]							,			SCREAMING_SNAKE_CASE__		:							Optional[int]  )     ->							Tuple:
						__lowerCamelCase    					=	['''on_init_end''', '''on_train_begin''']
						__lowerCamelCase    					=	0
						__lowerCamelCase    					=	len(trainer.get_eval_dataloader()  )
						__lowerCamelCase    					=	['''on_prediction_step'''] * len(trainer.get_eval_dataloader()  ) + ['''on_log''', '''on_evaluate''']
						for _ in range(trainer.state.num_train_epochs  ):
										expected_events.append('''on_epoch_begin'''  )
										for _ in range(SCREAMING_SNAKE_CASE__  ):
														step += 1
														expected_events += ["on_step_begin", "on_step_end"]
														if step % trainer.args.logging_steps == 0:
																		expected_events.append('''on_log'''  )
														if trainer.args.evaluation_strategy == IntervalStrategy.STEPS and step % trainer.args.eval_steps == 0:
																		expected_events += evaluation_events.copy()
														if step % trainer.args.save_steps == 0:
																		expected_events.append('''on_save'''  )
										expected_events.append('''on_epoch_end'''  )
										if trainer.args.evaluation_strategy == IntervalStrategy.EPOCH:
														expected_events += evaluation_events.copy()
						expected_events += ["on_log", "on_train_end"]
						return expected_events






		def  __A       (		self		:							Union[str, Any]  )     ->							int:
						__lowerCamelCase    					=	self.get_trainer()
						__lowerCamelCase    					=	DEFAULT_CALLBACKS.copy() + [ProgressCallback]
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						# Callbacks passed at init are added to the default callbacks
						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]  )
						expected_callbacks.append(SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						# TrainingArguments.disable_tqdm controls if use ProgressCallback or PrinterCallback
						__lowerCamelCase    					=	self.get_trainer(disable_tqdm=SCREAMING_SNAKE_CASE__  )
						__lowerCamelCase    					=	DEFAULT_CALLBACKS.copy() + [PrinterCallback]
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )






		def  __A       (		self		:							List[Any]  )     ->							str:
						__lowerCamelCase    					=	DEFAULT_CALLBACKS.copy() + [ProgressCallback]
						__lowerCamelCase    					=	self.get_trainer()

						# We can add, pop, or remove by class name
						trainer.remove_callback(SCREAMING_SNAKE_CASE__  )
						expected_callbacks.remove(SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	self.get_trainer()
						__lowerCamelCase    					=	trainer.pop_callback(SCREAMING_SNAKE_CASE__  )
						self.assertEqual(cb.__class__							,			SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						trainer.add_callback(SCREAMING_SNAKE_CASE__  )
						expected_callbacks.insert(0							,			SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						# We can also add, pop, or remove by instance
						__lowerCamelCase    					=	self.get_trainer()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[0]
						trainer.remove_callback(SCREAMING_SNAKE_CASE__  )
						expected_callbacks.remove(SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	self.get_trainer()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[0]
						__lowerCamelCase    					=	trainer.pop_callback(SCREAMING_SNAKE_CASE__  )
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )

						trainer.add_callback(SCREAMING_SNAKE_CASE__  )
						expected_callbacks.insert(0							,			SCREAMING_SNAKE_CASE__  )
						self.check_callbacks_equality(trainer.callback_handler.callbacks							,			SCREAMING_SNAKE_CASE__  )







		def  __A       (		self		:							Union[str, Any]  )     ->							Any:
						import warnings

						# XXX: for now ignore scatter_gather warnings in this test since it's not relevant to what's being tested
						warnings.simplefilter(action='''ignore'''							,			category=SCREAMING_SNAKE_CASE__  )

						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]  )
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						# Independent log/save/eval
						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]							,			logging_steps=5  )
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]							,			save_steps=5  )
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]							,			eval_steps=5							,			evaluation_strategy='''steps'''  )
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						__lowerCamelCase    					=	self.get_trainer(callbacks=[MyTestTrainerCallback]							,			evaluation_strategy='''epoch'''  )
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						# A bit of everything
						__lowerCamelCase    					=	self.get_trainer(
						    callbacks=[MyTestTrainerCallback]							,			logging_steps=3							,			save_steps=10							,			eval_steps=5							,			evaluation_strategy='''steps'''							,			)
						trainer.train()
						__lowerCamelCase    					=	trainer.callback_handler.callbacks[-2].events
						self.assertEqual(SCREAMING_SNAKE_CASE__							,			self.get_expected_events(SCREAMING_SNAKE_CASE__  )  )

						# warning should be emitted for duplicated callbacks
						with patch('''transformers.trainer_callback.logger.warning'''  ) as warn_mock:
										__lowerCamelCase    					=	self.get_trainer(
										    callbacks=[MyTestTrainerCallback, MyTestTrainerCallback]							,			)
										assert str(SCREAMING_SNAKE_CASE__  ) in warn_mock.call_args[0][0]



