




'''simple docstring'''



from __future__ import annotations

import os
import tempfile
import unittest

from transformers import ConvBertConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TFConvBertForMaskedLM,
         TFConvBertForMultipleChoice,
         TFConvBertForQuestionAnswering,
         TFConvBertForSequenceClassification,
         TFConvBertForTokenClassification,
         TFConvBertModel,
     )





class      lowerCAmelCase :


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=13     ,	__SCREAMING_SNAKE_CASE=7     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=99     ,	__SCREAMING_SNAKE_CASE=32     ,	__SCREAMING_SNAKE_CASE=2     ,	__SCREAMING_SNAKE_CASE=4     ,	__SCREAMING_SNAKE_CASE=37     ,	__SCREAMING_SNAKE_CASE="gelu"     ,	__SCREAMING_SNAKE_CASE=0.1     ,	__SCREAMING_SNAKE_CASE=0.1     ,	__SCREAMING_SNAKE_CASE=512     ,	__SCREAMING_SNAKE_CASE=16     ,	__SCREAMING_SNAKE_CASE=2     ,	__SCREAMING_SNAKE_CASE=0.02     ,	__SCREAMING_SNAKE_CASE=3     ,	__SCREAMING_SNAKE_CASE=4     ,	__SCREAMING_SNAKE_CASE=None     ,	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	parent
            __snake_case            =	13
            __snake_case            =	7
            __snake_case            =	True
            __snake_case            =	True
            __snake_case            =	True
            __snake_case            =	True
            __snake_case            =	99
            __snake_case            =	384
            __snake_case            =	2
            __snake_case            =	4
            __snake_case            =	37
            __snake_case            =	'''gelu'''
            __snake_case            =	0.1
            __snake_case            =	0.1
            __snake_case            =	512
            __snake_case            =	16
            __snake_case            =	2
            __snake_case            =	0.02
            __snake_case            =	3
            __snake_case            =	4
            __snake_case            =	128
            __snake_case            =	2
            __snake_case            =	9
            __snake_case            =	1
            __snake_case            =	None


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	ids_tensor([self.batch_size, self.seq_length]     ,	self.vocab_size	)

            __snake_case            =	None
            if self.use_input_mask:
                 __snake_case            =	random_attention_mask([self.batch_size, self.seq_length]	)

            __snake_case            =	None
            if self.use_token_type_ids:
                 __snake_case            =	ids_tensor([self.batch_size, self.seq_length]     ,	self.type_vocab_size	)

            __snake_case            =	None
            __snake_case            =	None
            __snake_case            =	None
            if self.use_labels:
                 __snake_case            =	ids_tensor([self.batch_size]     ,	self.type_sequence_label_size	)
                 __snake_case            =	ids_tensor([self.batch_size, self.seq_length]     ,	self.num_labels	)
                 __snake_case            =	ids_tensor([self.batch_size]     ,	self.num_choices	)

            __snake_case            =	ConvBertConfig(
                vocab_size=self.vocab_size     ,	hidden_size=self.hidden_size     ,	num_hidden_layers=self.num_hidden_layers     ,	num_attention_heads=self.num_attention_heads     ,	intermediate_size=self.intermediate_size     ,	hidden_act=self.hidden_act     ,	hidden_dropout_prob=self.hidden_dropout_prob     ,	attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,	max_position_embeddings=self.max_position_embeddings     ,	type_vocab_size=self.type_vocab_size     ,	initializer_range=self.initializer_range     ,	return_dict=__SCREAMING_SNAKE_CASE     ,	)

            return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	TFConvBertModel(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	{'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}

            __snake_case            =	[input_ids, input_mask]
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)

            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)

            self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Union[str, Any]:



            '''simple docstring'''




            __snake_case            =	TFConvBertForMaskedLM(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	{
                '''input_ids''': input_ids,
                '''attention_mask''': input_mask,
                '''token_type_ids''': token_type_ids,
            }
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.vocab_size)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	self.num_labels
            __snake_case            =	TFConvBertForSequenceClassification(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	{
                '''input_ids''': input_ids,
                '''attention_mask''': input_mask,
                '''token_type_ids''': token_type_ids,
            }

            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_labels)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	str:



            '''simple docstring'''




            __snake_case            =	self.num_choices
            __snake_case            =	TFConvBertForMultipleChoice(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,	1	)     ,	(1, self.num_choices, 1)	)
            __snake_case            =	tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,	1	)     ,	(1, self.num_choices, 1)	)
            __snake_case            =	tf.tile(tf.expand_dims(__SCREAMING_SNAKE_CASE     ,	1	)     ,	(1, self.num_choices, 1)	)
            __snake_case            =	{
                '''input_ids''': multiple_choice_inputs_ids,
                '''attention_mask''': multiple_choice_input_mask,
                '''token_type_ids''': multiple_choice_token_type_ids,
            }
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_choices)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Union[str, Any]:



            '''simple docstring'''




            __snake_case            =	self.num_labels
            __snake_case            =	TFConvBertForTokenClassification(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	{
                '''input_ids''': input_ids,
                '''attention_mask''': input_mask,
                '''token_type_ids''': token_type_ids,
            }
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.num_labels)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	str:



            '''simple docstring'''




            __snake_case            =	TFConvBertForQuestionAnswering(config=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	{
                '''input_ids''': input_ids,
                '''attention_mask''': input_mask,
                '''token_type_ids''': token_type_ids,
            }

            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)
            self.parent.assertEqual(result.start_logits.shape     ,	(self.batch_size, self.seq_length)	)
            self.parent.assertEqual(result.end_logits.shape     ,	(self.batch_size, self.seq_length)	)




       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            __snake_case            =	self.prepare_config_and_inputs()
            (
                (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     (
                __snake_case
            )       ,     
            )            =	config_and_inputs
            __snake_case            =	{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
            return config, inputs_dict





@require_tf
class      lowerCAmelCase (			__lowerCAmelCase					, __lowerCAmelCase					, unittest.TestCase):
       __lowercase	:   str										=      (
           (
               TFConvBertModel,
               TFConvBertForMaskedLM,
               TFConvBertForQuestionAnswering,
               TFConvBertForSequenceClassification,
               TFConvBertForTokenClassification,
               TFConvBertForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       __lowercase	:   Optional[int]										=      (
           {
               '''feature-extraction''': TFConvBertModel,
               '''fill-mask''': TFConvBertForMaskedLM,
               '''question-answering''': TFConvBertForQuestionAnswering,
               '''text-classification''': TFConvBertForSequenceClassification,
               '''token-classification''': TFConvBertForTokenClassification,
               '''zero-shot''': TFConvBertForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       __lowercase	:   Optional[Any]										=      False
       __lowercase	:   List[str]										=      False
       __lowercase	:   Union[str, Any]										=      False


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



            '''simple docstring'''




            __snake_case            =	TFConvBertModelTester(self	)
            __snake_case            =	ConfigTester(self     ,	config_class=__SCREAMING_SNAKE_CASE     ,	hidden_size=37	)


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            self.config_tester.run_common_tests()


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE	)


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



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE	)


       @slow
       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case            =	True
            __snake_case            =	True

            if hasattr(__SCREAMING_SNAKE_CASE     ,	'''use_cache'''	):
                 __snake_case            =	True

            __snake_case            =	getattr(self.model_tester     ,	'''encoder_seq_length'''     ,	self.model_tester.seq_length	)
            __snake_case            =	getattr(self.model_tester     ,	'''key_length'''     ,	__SCREAMING_SNAKE_CASE	)

            for model_class in self.all_model_classes:
                 __snake_case            =	self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	len(model(__SCREAMING_SNAKE_CASE	)	)

                 with tempfile.TemporaryDirectory() as tmpdirname:
                      model.save_pretrained(__SCREAMING_SNAKE_CASE     ,	saved_model=__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	os.path.join(__SCREAMING_SNAKE_CASE     ,	'''saved_model'''     ,	'''1'''	)
                      __snake_case            =	tf.keras.models.load_model(__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	model(__SCREAMING_SNAKE_CASE	)

                      if self.is_encoder_decoder:
                           __snake_case            =	outputs['''encoder_hidden_states''']
                           __snake_case            =	outputs['''encoder_attentions''']
                      else:
                           __snake_case            =	outputs['''hidden_states''']
                           __snake_case            =	outputs['''attentions''']

                      self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	__SCREAMING_SNAKE_CASE	)

                      __snake_case            =	getattr(
                          self.model_tester     ,	'''expected_num_hidden_layers'''     ,	self.model_tester.num_hidden_layers + 1	)

                      self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	__SCREAMING_SNAKE_CASE	)
                      self.assertListEqual(
                          list(output_hidden_states[0].shape[-2:]	)     ,	[self.model_tester.seq_length, self.model_tester.hidden_size]     ,	)

                      self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	self.model_tester.num_hidden_layers	)
                      self.assertListEqual(
                          list(output_attentions[0].shape[-3:]	)     ,	[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]     ,	)


       @slow
       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	TFConvBertModel.from_pretrained('''YituTech/conv-bert-base'''	)
            self.assertIsNotNone(__SCREAMING_SNAKE_CASE	)




       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()
            __snake_case            =	True
            __snake_case            =	getattr(self.model_tester     ,	'''decoder_seq_length'''     ,	self.model_tester.seq_length	)
            __snake_case            =	getattr(self.model_tester     ,	'''encoder_seq_length'''     ,	self.model_tester.seq_length	)
            __snake_case            =	getattr(self.model_tester     ,	'''key_length'''     ,	__SCREAMING_SNAKE_CASE	)
            __snake_case            =	getattr(self.model_tester     ,	'''key_length'''     ,	__SCREAMING_SNAKE_CASE	)

            def check_decoder_attentions_output(__SCREAMING_SNAKE_CASE	):
                 __snake_case            =	len(__SCREAMING_SNAKE_CASE	)
                 self.assertEqual(out_len % 2     ,	0	)
                 __snake_case            =	outputs.decoder_attentions
                 self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	self.model_tester.num_hidden_layers	)
                 self.assertListEqual(
                     list(decoder_attentions[0].shape[-3:]	)     ,	[self.model_tester.num_attention_heads / 2, decoder_seq_length, decoder_key_length]     ,	)

            def check_encoder_attentions_output(__SCREAMING_SNAKE_CASE	):
                 __snake_case            =	[
                     t.numpy() for t in (outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions)
                 ]
                 self.assertEqual(len(__SCREAMING_SNAKE_CASE	)     ,	self.model_tester.num_hidden_layers	)
                 self.assertListEqual(
                     list(attentions[0].shape[-3:]	)     ,	[self.model_tester.num_attention_heads / 2, encoder_seq_length, encoder_key_length]     ,	)

            for model_class in self.all_model_classes:
                 __snake_case            =	True
                 __snake_case            =	False
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model(self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)	)
                 __snake_case            =	len(__SCREAMING_SNAKE_CASE	)
                 self.assertEqual(config.output_hidden_states     ,	__SCREAMING_SNAKE_CASE	)
                 check_encoder_attentions_output(__SCREAMING_SNAKE_CASE	)

                 if self.is_encoder_decoder:
                      __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	model(self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)	)
                      self.assertEqual(config.output_hidden_states     ,	__SCREAMING_SNAKE_CASE	)
                      check_decoder_attentions_output(__SCREAMING_SNAKE_CASE	)

                 # Check that output attentions can also be changed via the config
                 del inputs_dict["output_attentions"]
                 __snake_case            =	True
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model(self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)	)
                 self.assertEqual(config.output_hidden_states     ,	__SCREAMING_SNAKE_CASE	)
                 check_encoder_attentions_output(__SCREAMING_SNAKE_CASE	)

                 # Check attention is always last and order is fine
                 __snake_case            =	True
                 __snake_case            =	True
                 __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model(self._prepare_for_class(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)	)

                 self.assertEqual(out_len + (2 if self.is_encoder_decoder else 1)     ,	len(__SCREAMING_SNAKE_CASE	)	)
                 self.assertEqual(model.config.output_hidden_states     ,	__SCREAMING_SNAKE_CASE	)
                 check_encoder_attentions_output(__SCREAMING_SNAKE_CASE	)





@require_tf
class      lowerCAmelCase (			unittest.TestCase):


       @slow
       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	TFConvBertModel.from_pretrained('''YituTech/conv-bert-base'''	)
            __snake_case            =	tf.constant([[0, 1, 2, 3, 4, 5]]	)
            __snake_case            =	model(__SCREAMING_SNAKE_CASE	)[0]

            __snake_case            =	[1, 6, 768]
            self.assertEqual(output.shape     ,	__SCREAMING_SNAKE_CASE	)

            __snake_case            =	tf.constant(
                [
                    [
                        [-0.03_475_493, -0.4_686_034, -0.30_638_832],
                        [0.22_637_248, -0.26_988_646, -0.7_423_424],
                        [0.10_324_868, -0.45_013_508, -0.58_280_784],
                    ]
                ]	)
            tf.debugging.assert_near(output[:, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=1E-4	)












'''simple docstring'''



import re
import time
from typing import Optional

import IPython.display as disp

from ..trainer_callback import TrainerCallback
from ..trainer_utils import IntervalStrategy, has_length







def       _UpperCamelCase			(_lowerCamelCase				:  Tuple						)-> List[str]:




     '''simple docstring'''





     __snake_case            =	int(_lowerCamelCase						)
     __snake_case       ,     __snake_case       ,     __snake_case            =	t // 36_00, (t // 60) % 60, t % 60
     return f'''{h}:{m:02d}:{s:02d}''' if h != 0 else f'''{m:02d}:{s:02d}'''







def       _UpperCamelCase			(_lowerCamelCase				:  Any ,						_lowerCamelCase				:  Union[str, Any] ,						_lowerCamelCase				:  str ,						_lowerCamelCase				:  int ,						_lowerCamelCase				:  List[Any]=3_00						)-> int:




     '''simple docstring'''





     return f'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''







def       _UpperCamelCase			(_lowerCamelCase				:  int						)-> List[Any]:




     '''simple docstring'''





     __snake_case            =	'''<table border="1" class="dataframe">\n'''
     html_code += """  <thead>\n <tr style="text-align: left;">\n"""
     for i in items[0]:
          html_code += f'''      <th>{i}</th>\n'''
     html_code += "    </tr>\n  </thead>\n  <tbody>\n"
     for line in items[1:]:
          html_code += "    <tr>\n"
          for elt in line:
               __snake_case            =	f'''{elt:.6f}''' if isinstance(_lowerCamelCase ,						_lowerCamelCase						) else str(_lowerCamelCase						)
               html_code += f'''      <td>{elt}</td>\n'''
          html_code += "    </tr>\n"
     html_code += "  </tbody>\n</table><p>"
     return html_code





class      lowerCAmelCase :
       __lowercase	:   str										=      5
       __lowercase	:   Optional[Any]										=      0.2


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = 300     ,	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	total
            __snake_case            =	'''''' if prefix is None else prefix
            __snake_case            =	leave
            __snake_case            =	parent
            __snake_case            =	width
            __snake_case            =	None
            __snake_case            =	None
            __snake_case            =	None


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = False     ,	__SCREAMING_SNAKE_CASE = None	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	value
            if comment is not None:
                 __snake_case            =	comment
            if self.last_value is None:
                 __snake_case            =	__snake_case            =	time.time()
                 __snake_case            =	__snake_case            =	value
                 __snake_case            =	__snake_case            =	None
                 __snake_case            =	self.warmup
                 __snake_case            =	1
                 self.update_bar(__SCREAMING_SNAKE_CASE	)
            elif value <= self.last_value and not force_update:
                 return
            elif force_update or self.first_calls > 0 or value >= min(self.last_value + self.wait_for     ,	self.total	):
                 if self.first_calls > 0:
                      self.first_calls -= 1
                 __snake_case            =	time.time()
                 __snake_case            =	current_time - self.start_time
                 # We could have value = self.start_value if the update is called twixe with the same start value.
                 if value > self.start_value:
                      __snake_case            =	self.elapsed_time / (value - self.start_value)
                 else:
                      __snake_case            =	None
                 if value >= self.total:
                      __snake_case            =	self.total
                      __snake_case            =	None
                      if not self.leave:
                           self.close()
                 elif self.average_time_per_item is not None:
                      __snake_case            =	self.average_time_per_item * (self.total - value)
                 self.update_bar(__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	value
                 __snake_case            =	current_time
                 if self.average_time_per_item is None:
                      __snake_case            =	1
                 else:
                      __snake_case            =	max(int(self.update_every / self.average_time_per_item	)     ,	1	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	''' ''' * (len(str(self.total	)	) - len(str(__SCREAMING_SNAKE_CASE	)	)) + str(__SCREAMING_SNAKE_CASE	)
            if self.elapsed_time is None:
                 __snake_case            =	F'''[{spaced_value}/{self.total} : < :'''
            elif self.predicted_remaining is None:
                 __snake_case            =	F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time	)}'''
            else:
                 __snake_case            =	(
                     F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time	)} <'''
                     F''' {format_time(self.predicted_remaining	)}'''
                 )
                 self.label += F''', {1/self.average_time_per_item:.2f} it/s'''
            self.label += "]" if self.comment is None or len(self.comment	) == 0 else F''', {self.comment}]'''
            self.display()


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



            '''simple docstring'''




            __snake_case            =	html_progress_bar(self.value     ,	self.total     ,	self.prefix     ,	self.label     ,	self.width	)
            if self.parent is not None:
                 # If this is a child bar, the parent will take care of the display.
                 self.parent.display()
                 return
            if self.output is None:
                 __snake_case            =	disp.display(disp.HTML(self.html_code	)     ,	display_id=__SCREAMING_SNAKE_CASE	)
            else:
                 self.output.update(disp.HTML(self.html_code	)	)




       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




            if self.parent is None and self.output is not None:
                 self.output.update(disp.HTML(''''''	)	)





class      lowerCAmelCase (			__lowerCAmelCase):


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None	)   ->	Any:



            '''simple docstring'''




            super().__init__(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	None if column_names is None else [column_names]
            __snake_case            =	None


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	html_progress_bar(self.value     ,	self.total     ,	self.prefix     ,	self.label     ,	self.width	)
            if self.inner_table is not None:
                 self.html_code += text_to_html_table(self.inner_table	)
            if self.child_bar is not None:
                 self.html_code += self.child_bar.html_code
            if self.output is None:
                 __snake_case            =	disp.display(disp.HTML(self.html_code	)     ,	display_id=__SCREAMING_SNAKE_CASE	)
            else:
                 self.output.update(disp.HTML(self.html_code	)	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE	)   ->	Dict:



            '''simple docstring'''




            if self.inner_table is None:
                 __snake_case            =	[list(values.keys()	), list(values.values()	)]
            else:
                 __snake_case            =	self.inner_table[0]
                 if len(self.inner_table	) == 1:
                      # We give a chance to update the column names at the first iteration
                      for key in values.keys():
                           if key not in columns:
                                columns.append(__SCREAMING_SNAKE_CASE	)
                      __snake_case            =	columns
                 self.inner_table.append([values[c] for c in columns]	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	__SCREAMING_SNAKE_CASE=300	)   ->	List[str]:



            '''simple docstring'''




            __snake_case            =	NotebookProgressBar(__SCREAMING_SNAKE_CASE     ,	prefix=__SCREAMING_SNAKE_CASE     ,	parent=self     ,	width=__SCREAMING_SNAKE_CASE	)
            return self.child_bar




       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	None
            self.display()





class      lowerCAmelCase (			__lowerCAmelCase):


       def __init__( self	)   ->	str:



            '''simple docstring'''




            __snake_case            =	None
            __snake_case            =	None
            __snake_case            =	False


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            __snake_case            =	'''Epoch''' if args.evaluation_strategy == IntervalStrategy.EPOCH else '''Step'''
            __snake_case            =	0
            __snake_case            =	0
            __snake_case            =	[self.first_column] + ['''Training Loss''']
            if args.evaluation_strategy != IntervalStrategy.NO:
                 column_names.append('''Validation Loss'''	)
            __snake_case            =	NotebookTrainingTracker(state.max_steps     ,	__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	List[Any]:



            '''simple docstring'''




            __snake_case            =	int(state.epoch	) if int(state.epoch	) == state.epoch else F'''{state.epoch:.2f}'''
            self.training_tracker.update(
                state.global_step + 1     ,	comment=F'''Epoch {epoch}/{state.num_train_epochs}'''     ,	force_update=self._force_next_update     ,	)
            __snake_case            =	False


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            if not has_length(__SCREAMING_SNAKE_CASE	):
                 return
            if self.prediction_bar is None:
                 if self.training_tracker is not None:
                      __snake_case            =	self.training_tracker.add_child(len(__SCREAMING_SNAKE_CASE	)	)
                 else:
                      __snake_case            =	NotebookProgressBar(len(__SCREAMING_SNAKE_CASE	)	)
                 self.prediction_bar.update(1	)
            else:
                 self.prediction_bar.update(self.prediction_bar.value + 1	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            if self.prediction_bar is not None:
                 self.prediction_bar.close()
            __snake_case            =	None


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	List[Any]:



            '''simple docstring'''




            if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
                 __snake_case            =	{'''Training Loss''': logs['''loss''']}
                 # First column is necessarily Step sine we're not in epoch eval strategy
                 __snake_case            =	state.global_step
                 self.training_tracker.write_line(__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=None     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[Any]:



            '''simple docstring'''




            if self.training_tracker is not None:
                 __snake_case            =	{'''Training Loss''': '''No log''', '''Validation Loss''': '''No log'''}
                 for log in reversed(state.log_history	):
                      if "loss" in log:
                           __snake_case            =	log['''loss''']
                           break

                 if self.first_column == "Epoch":
                      __snake_case            =	int(state.epoch	)
                 else:
                      __snake_case            =	state.global_step
                 __snake_case            =	'''eval'''
                 for k in metrics:
                      if k.endswith('''_loss'''	):
                           __snake_case            =	re.sub(r'''\_loss$'''     ,	''''''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop('''total_flos'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop('''epoch'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_runtime'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_samples_per_second'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_steps_per_second'''     ,	__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	metrics.pop(F'''{metric_key_prefix}_jit_compilation_time'''     ,	__SCREAMING_SNAKE_CASE	)
                 for k, v in metrics.items():
                      if k == F'''{metric_key_prefix}_loss''':
                           __snake_case            =	v
                      else:
                           __snake_case            =	k.split('''_'''	)
                           __snake_case            =	''' '''.join([part.capitalize() for part in splits[1:]]	)
                           __snake_case            =	v
                 self.training_tracker.write_line(__SCREAMING_SNAKE_CASE	)
                 self.training_tracker.remove_child()
                 __snake_case            =	None
                 # Evaluation takes a long time so we should force the next update.
                 __snake_case            =	True




       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)   ->	Optional[int]:



            '''simple docstring'''




            self.training_tracker.update(
                state.global_step     ,	comment=F'''Epoch {int(state.epoch	)}/{state.num_train_epochs}'''     ,	force_update=__SCREAMING_SNAKE_CASE	)
            __snake_case            =	None






