





'''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 	__lowerCamelCase			(      __lowerCAmelCase       :							str		)		->  Tuple:
   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 	__lowerCamelCase			(      __lowerCAmelCase       :							List[str]      ,    __lowerCAmelCase       :							int      ,    __lowerCAmelCase       :							Dict      ,    __lowerCAmelCase       :							Any      ,    __lowerCAmelCase       :							List[Any]=3_00		)		->  List[Any]:
   # docstyle-ignore
   return F'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''





def 	__lowerCamelCase			(      __lowerCAmelCase       :							List[str]		)		->  List[Any]:
   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		:






     """simple docstring"""






     snake_case_						      =   5
     snake_case_						      =   0.2



     def __init__(   self							:			Optional[Any]   ,       __snake_case							:			int   ,       __snake_case							:			Optional[str] = None   ,       __snake_case							:			bool = True   ,       __snake_case							:			Optional["NotebookTrainingTracker"] = None   ,       __snake_case							:			int = 3_00   ,       )->	List[Any]:
        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							:			Union[str, Any]   ,       __snake_case							:			int   ,       __snake_case							:			bool = False   ,       __snake_case							:			str = None						)->	Tuple:
        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(__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(__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							:			Union[str, Any]   ,       __snake_case							:			List[str]   ,       __snake_case							:			Union[str, Any]=None						)->	Any:
        snake_case 						=   """ """ * (len(str(self.total						)						) - len(str(__snake_case						)						)) + str(__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							:			Optional[int]						)->	str:
        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=__snake_case						)
        else:
           self.output.update(disp.HTML(self.html_code						)						)



     def      lowerCAmelCase			(   self							:			str						)->	Optional[int]:
        if self.parent is None and self.output is not None:
           self.output.update(disp.HTML(""""""						)						)




class 			_lowerCAmelCase		(			A__	):






     """simple docstring"""






     def __init__(   self							:			List[Any]   ,       __snake_case							:			Dict   ,       __snake_case							:			Any=None						)->	Dict:
        super().__init__(__snake_case						)
        snake_case 						=   None if column_names is None else [column_names]
        snake_case 						=   None



     def      lowerCAmelCase			(   self							:			Union[str, Any]						)->	Union[str, Any]:
        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=__snake_case						)
        else:
           self.output.update(disp.HTML(self.html_code						)						)



     def      lowerCAmelCase			(   self							:			Dict   ,       __snake_case							:			Tuple						)->	Tuple:
        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(__snake_case						)
              snake_case 						=   columns
           self.inner_table.append([values[c] for c in columns]						)



     def      lowerCAmelCase			(   self							:			Dict   ,       __snake_case							:			List[str]   ,       __snake_case							:			List[Any]=None   ,       __snake_case							:			List[Any]=3_00						)->	Dict:
        snake_case 						=   NotebookProgressBar(__snake_case   ,       prefix=__snake_case   ,       parent=self   ,       width=__snake_case						)
        return self.child_bar



     def      lowerCAmelCase			(   self							:			Tuple						)->	Optional[Any]:
        snake_case 						=   None
        self.display()




class 			_lowerCAmelCase		(			A__	):






     """simple docstring"""






     def __init__(   self							:			str						)->	Any:
        snake_case 						=   None
        snake_case 						=   None
        snake_case 						=   False



     def      lowerCAmelCase			(   self							:			List[Any]   ,       __snake_case							:			str   ,       __snake_case							:			Dict   ,       __snake_case							:			Dict   ,       **__snake_case							:			List[Any]						)->	Union[str, Any]:
        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   ,       __snake_case						)



     def      lowerCAmelCase			(   self							:			Dict   ,       __snake_case							:			Optional[Any]   ,       __snake_case							:			Any   ,       __snake_case							:			Any   ,       **__snake_case							:			Union[str, Any]						)->	str:
        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							:			Tuple   ,       __snake_case							:			int   ,       __snake_case							:			Optional[Any]   ,       __snake_case							:			Any   ,       __snake_case							:			Union[str, Any]=None   ,       **__snake_case							:			Tuple						)->	List[Any]:
        if not has_length(__snake_case						):
           return
        if self.prediction_bar is None:
           if self.training_tracker is not None:
              snake_case 						=   self.training_tracker.add_child(len(__snake_case						)						)
           else:
              snake_case 						=   NotebookProgressBar(len(__snake_case						)						)
           self.prediction_bar.update(1						)
        else:
           self.prediction_bar.update(self.prediction_bar.value + 1						)



     def      lowerCAmelCase			(   self							:			Optional[Any]   ,       __snake_case							:			Any   ,       __snake_case							:			Union[str, Any]   ,       __snake_case							:			str   ,       **__snake_case							:			List[str]						)->	int:
        if self.prediction_bar is not None:
           self.prediction_bar.close()
        snake_case 						=   None



     def      lowerCAmelCase			(   self							:			Union[str, Any]   ,       __snake_case							:			Optional[Any]   ,       __snake_case							:			int   ,       __snake_case							:			str   ,       __snake_case							:			Tuple=None   ,       **__snake_case							:			Any						)->	Dict:
        # Only for when there is no evaluation
        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(__snake_case						)



     def      lowerCAmelCase			(   self							:			Union[str, Any]   ,       __snake_case							:			List[Any]   ,       __snake_case							:			Tuple   ,       __snake_case							:			Dict   ,       __snake_case							:			Tuple=None   ,       **__snake_case							:			Any						)->	Union[str, Any]:
        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$"""   ,       """"""   ,       __snake_case						)
           snake_case 						=   metrics.pop("""total_flos"""   ,       __snake_case						)
           snake_case 						=   metrics.pop("""epoch"""   ,       __snake_case						)
           snake_case 						=   metrics.pop(f'''{metric_key_prefix}_runtime'''   ,       __snake_case						)
           snake_case 						=   metrics.pop(f'''{metric_key_prefix}_samples_per_second'''   ,       __snake_case						)
           snake_case 						=   metrics.pop(f'''{metric_key_prefix}_steps_per_second'''   ,       __snake_case						)
           snake_case 						=   metrics.pop(f'''{metric_key_prefix}_jit_compilation_time'''   ,       __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(__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							:			Tuple   ,       __snake_case							:			Any   ,       __snake_case							:			List[Any]   ,       __snake_case							:			Optional[int]   ,       **__snake_case							:			Tuple						)->	int:
        self.training_tracker.update(
            state.global_step   ,       comment=f'''Epoch {int(state.epoch						)}/{state.num_train_epochs}'''   ,       force_update=__snake_case						)
        snake_case 						=   None








'''simple docstring'''




import logging

from transformers.configuration_utils import PretrainedConfig


_SCREAMING_SNAKE_CASE							     =			logging.getLogger(__name__)
class 			_lowerCAmelCase		(			A__	):






     """simple docstring"""






     snake_case_						      =   "masked_bert"



     def __init__(   self							:			Any   ,       __snake_case							:			Optional[Any]=3_05_22   ,       __snake_case							:			List[Any]=7_68   ,       __snake_case							:			int=12   ,       __snake_case							:			List[str]=12   ,       __snake_case							:			int=30_72   ,       __snake_case							:			Optional[int]="gelu"   ,       __snake_case							:			Any=0.1   ,       __snake_case							:			Tuple=0.1   ,       __snake_case							:			List[str]=5_12   ,       __snake_case							:			Tuple=2   ,       __snake_case							:			Tuple=0.02   ,       __snake_case							:			Tuple=1e-12   ,       __snake_case							:			Union[str, Any]=0   ,       __snake_case							:			int="topK"   ,       __snake_case							:			int="constant"   ,       __snake_case							:			List[str]=0.0   ,       **__snake_case							:			Any   ,       )->	Union[str, Any]:
        super().__init__(pad_token_id=__snake_case   ,       **__snake_case						)

        snake_case 						=   vocab_size
        snake_case 						=   hidden_size
        snake_case 						=   num_hidden_layers
        snake_case 						=   num_attention_heads
        snake_case 						=   hidden_act
        snake_case 						=   intermediate_size
        snake_case 						=   hidden_dropout_prob
        snake_case 						=   attention_probs_dropout_prob
        snake_case 						=   max_position_embeddings
        snake_case 						=   type_vocab_size
        snake_case 						=   initializer_range
        snake_case 						=   layer_norm_eps
        snake_case 						=   pruning_method
        snake_case 						=   mask_init
        snake_case 						=   mask_scale

