"""simple docstring"""







from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, 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.models.layoutlm.modeling_tf_layoutlm import (
						    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
						    TFLayoutLMForMaskedLM,
						    TFLayoutLMForQuestionAnswering,
						    TFLayoutLMForSequenceClassification,
						    TFLayoutLMForTokenClassification,
						    TFLayoutLMModel,
						)



class  _lowerCamelCase			:







				def __init__( self    :       List[str]			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       List[Any]=1_3			,					lowerCamelCase_    :       Tuple=7			,					lowerCamelCase_    :       str=True			,					lowerCamelCase_    :       Dict=True			,					lowerCamelCase_    :       Optional[Any]=True			,					lowerCamelCase_    :       Tuple=True			,					lowerCamelCase_    :       List[Any]=9_9			,					lowerCamelCase_    :       Optional[Any]=3_2			,					lowerCamelCase_    :       List[str]=2			,					lowerCamelCase_    :       int=4			,					lowerCamelCase_    :       Optional[Any]=3_7			,					lowerCamelCase_    :       Optional[Any]="gelu"			,					lowerCamelCase_    :       Optional[Any]=0.1			,					lowerCamelCase_    :       Tuple=0.1			,					lowerCamelCase_    :       Dict=5_1_2			,					lowerCamelCase_    :       Any=1_6			,					lowerCamelCase_    :       str=2			,					lowerCamelCase_    :       Optional[int]=0.02			,					lowerCamelCase_    :       Dict=3			,					lowerCamelCase_    :       List[str]=4			,					lowerCamelCase_    :       int=None			,					lowerCamelCase_    :       int=1_0_0_0			,					):

					"""simple docstring"""






					_lowercase :    Dict							=							parent
					_lowercase :    Optional[int]							=							batch_size
					_lowercase :    List[str]							=							seq_length
					_lowercase :    Union[str, Any]							=							is_training
					_lowercase :    str							=							use_input_mask
					_lowercase :    Optional[int]							=							use_token_type_ids
					_lowercase :    List[Any]							=							use_labels
					_lowercase :    Optional[int]							=							vocab_size
					_lowercase :    Optional[Any]							=							hidden_size
					_lowercase :    int							=							num_hidden_layers
					_lowercase :    Union[str, Any]							=							num_attention_heads
					_lowercase :    Dict							=							intermediate_size
					_lowercase :    Optional[int]							=							hidden_act
					_lowercase :    List[str]							=							hidden_dropout_prob
					_lowercase :    Optional[Any]							=							attention_probs_dropout_prob
					_lowercase :    List[str]							=							max_position_embeddings
					_lowercase :    Union[str, Any]							=							type_vocab_size
					_lowercase :    List[Any]							=							type_sequence_label_size
					_lowercase :    Optional[int]							=							initializer_range
					_lowercase :    Optional[int]							=							num_labels
					_lowercase :    int							=							num_choices
					_lowercase :    int							=							scope
					_lowercase :    int							=							range_bbox







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    List[str]							=							ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size						)

					# convert bbox to numpy since TF does not support item assignment
					_lowercase :    Optional[Any]							=							ids_tensor([self.batch_size, self.seq_length, 4]			,					self.range_bbox						).numpy()
					# Ensure that bbox is legal
					for i in range(bbox.shape[0]						):
						for j in range(bbox.shape[1]						):
							if bbox[i, j, 3] < bbox[i, j, 1]:
								_lowercase :    str							=							bbox[i, j, 3]
								_lowercase :    Dict							=							bbox[i, j, 1]
								_lowercase :    Union[str, Any]							=							t
							if bbox[i, j, 2] < bbox[i, j, 0]:
								_lowercase :    List[str]							=							bbox[i, j, 2]
								_lowercase :    int							=							bbox[i, j, 0]
								_lowercase :    Tuple							=							t
					_lowercase :    str							=							tf.convert_to_tensor(lowerCamelCase_						)

					_lowercase :    Union[str, Any]							=							None
					if self.use_input_mask:
						_lowercase :    str							=							random_attention_mask([self.batch_size, self.seq_length]						)

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

					_lowercase :    Dict							=							None
					_lowercase :    int							=							None
					_lowercase :    Union[str, Any]							=							None
					if self.use_labels:
						_lowercase :    Any							=							ids_tensor([self.batch_size]			,					self.type_sequence_label_size						)
						_lowercase :    str							=							ids_tensor([self.batch_size, self.seq_length]			,					self.num_labels						)
						_lowercase :    str							=							ids_tensor([self.batch_size]			,					self.num_choices						)

					_lowercase :    str							=							LayoutLMConfig(
					    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 config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels







				def 							__UpperCAmelCase					( self    :       Dict			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Union[str, Any]			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Any						):

					"""simple docstring"""






					_lowercase :    Tuple							=							TFLayoutLMModel(config=lowerCamelCase_						)

					_lowercase :    Tuple							=							model(lowerCamelCase_			,					lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)
					_lowercase :    List[Any]							=							model(lowerCamelCase_			,					lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)
					_lowercase :    str							=							model(lowerCamelCase_			,					lowerCamelCase_						)
					self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size)						)
					self.parent.assertEqual(result.pooler_output.shape			,					(self.batch_size, self.hidden_size)						)







				def 							__UpperCAmelCase					( self    :       List[Any]			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    str							=							TFLayoutLMForMaskedLM(config=lowerCamelCase_						)

					_lowercase :    Union[str, Any]							=							model(lowerCamelCase_			,					lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_			,					labels=lowerCamelCase_						)
					self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.seq_length, self.vocab_size)						)







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    Dict							=							self.num_labels
					_lowercase :    Optional[Any]							=							TFLayoutLMForSequenceClassification(config=lowerCamelCase_						)

					_lowercase :    Optional[int]							=							model(lowerCamelCase_			,					lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)
					self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.num_labels)						)







				def 							__UpperCAmelCase					( self    :       Any			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Union[str, Any]			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[int]						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							self.num_labels
					_lowercase :    str							=							TFLayoutLMForTokenClassification(config=lowerCamelCase_						)

					_lowercase :    Optional[Any]							=							model(lowerCamelCase_			,					lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_			,					labels=lowerCamelCase_						)
					self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.seq_length, self.num_labels)						)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       str						):

					"""simple docstring"""






					_lowercase :    List[Any]							=							TFLayoutLMForQuestionAnswering(config=lowerCamelCase_						)

					_lowercase :    Optional[Any]							=							model(lowerCamelCase_			,					lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)
					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 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    int							=							self.prepare_config_and_inputs()
					(
					    (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      (
					    _lowercase
					)				,      
					) :    List[str]							=							config_and_inputs
					_lowercase :    List[Any]							=							{
					    'input_ids': input_ids,
					    'bbox': bbox,
					    'token_type_ids': token_type_ids,
					    'attention_mask': input_mask,
					}
					return config, inputs_dict



@require_tf
class  _lowerCamelCase			(__lowerCamelCase						,							__lowerCamelCase						,							unittest.TestCase     ):
				_snake_case     =  (
				    (
				        TFLayoutLMModel,
				        TFLayoutLMForMaskedLM,
				        TFLayoutLMForTokenClassification,
				        TFLayoutLMForSequenceClassification,
				        TFLayoutLMForQuestionAnswering,
				    )
				    if is_tf_available()
				    else ()
				)
				_snake_case     =  (
				    {
				        "feature-extraction": TFLayoutLMModel,
				        "fill-mask": TFLayoutLMForMaskedLM,
				        "text-classification": TFLayoutLMForSequenceClassification,
				        "token-classification": TFLayoutLMForTokenClassification,
				        "zero-shot": TFLayoutLMForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				_snake_case     =  False
				_snake_case     =  True
				_snake_case     =  10







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					_lowercase :    Dict							=							TFLayoutLMModelTester(self						)
					_lowercase :    Dict							=							ConfigTester(self			,					config_class=lowerCamelCase_			,					hidden_size=3_7						)







				def 							__UpperCAmelCase					( self    :       Optional[int]						):

					"""simple docstring"""






					self.config_tester.run_common_tests()







				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Dict						):

					"""simple docstring"""






					_lowercase :    str							=							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					_lowercase :    List[str]							=							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_token_classification(*lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    List[str]							=							self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*lowerCamelCase_						)







				@slow
				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






					for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						_lowercase :    Dict							=							TFLayoutLMModel.from_pretrained(lowerCamelCase_						)
						self.assertIsNotNone(lowerCamelCase_						)







				@unittest.skip('Onnx compliancy broke with TF 2.10'						)
				def 							__UpperCAmelCase					( self    :       Tuple						):

					"""simple docstring"""






					pass



def      __lowerCAmelCase(		):






	"""simple docstring"""





	_lowercase :    Any							=							tf.convert_to_tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]			)  # noqa: E231
	_lowercase :    int							=							tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]			)  # noqa: E231
	_lowercase :    Dict							=							tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]]			)  # noqa: E231
	_lowercase :    int							=							tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]			)  # noqa: E231
	# these are sequence labels (i.e. at the token level)
	_lowercase :    Optional[int]							=							tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]			)  # noqa: E231
	# fmt: on

	return input_ids, attention_mask, bbox, token_type_ids, labels







@require_tf
class  _lowerCamelCase			(unittest.TestCase     ):







				@slow
				def 							__UpperCAmelCase					( self    :       List[str]						):

					"""simple docstring"""






					_lowercase :    List[Any]							=							TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'						)

					_lowercase				,      _lowercase				,      _lowercase				,      _lowercase				,      _lowercase :    int							=							prepare_layoutlm_batch_inputs()

					# forward pass
					_lowercase :    Union[str, Any]							=							model(input_ids=lowerCamelCase_			,					bbox=lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)

					# test the sequence output on [0, :3, :3]
					_lowercase :    Optional[int]							=							tf.convert_to_tensor(
					    [[0.1785, -0.1947, -0.0425], [-0.3254, -0.2807, 0.2553], [-0.5391, -0.3322, 0.3364]]			,					)

					self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]			,					lowerCamelCase_			,					atol=1E-3						)						)

					# test the pooled output on [1, :3]
					_lowercase :    List[Any]							=							tf.convert_to_tensor([-0.6580, -0.0214, 0.8552]						)

					self.assertTrue(np.allclose(outputs.pooler_output[1, :3]			,					lowerCamelCase_			,					atol=1E-3						)						)







				@slow
				def 							__UpperCAmelCase					( self    :       List[Any]						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'			,					num_labels=2						)

					_lowercase				,      _lowercase				,      _lowercase				,      _lowercase				,      _lowercase :    List[str]							=							prepare_layoutlm_batch_inputs()

					# forward pass
					_lowercase :    Any							=							model(
					    input_ids=lowerCamelCase_			,					bbox=lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_			,					labels=tf.convert_to_tensor([1, 1]						)			,					)

					# test whether we get a loss as a scalar
					_lowercase :    int							=							outputs.loss
					_lowercase :    str							=							(2,)
					self.assertEqual(loss.shape			,					lowerCamelCase_						)

					# test the shape of the logits
					_lowercase :    str							=							outputs.logits
					_lowercase :    Optional[int]							=							(2, 2)
					self.assertEqual(logits.shape			,					lowerCamelCase_						)







				@slow
				def 							__UpperCAmelCase					( self    :       Optional[int]						):

					"""simple docstring"""






					_lowercase :    List[Any]							=							TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'			,					num_labels=1_3						)

					_lowercase				,      _lowercase				,      _lowercase				,      _lowercase				,      _lowercase :    Optional[int]							=							prepare_layoutlm_batch_inputs()

					# forward pass
					_lowercase :    str							=							model(
					    input_ids=lowerCamelCase_			,					bbox=lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_			,					labels=lowerCamelCase_						)

					# test the shape of the logits
					_lowercase :    Optional[Any]							=							outputs.logits
					_lowercase :    Tuple							=							tf.convert_to_tensor((2, 2_5, 1_3)						)
					self.assertEqual(logits.shape			,					lowerCamelCase_						)







				@slow
				def 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    Optional[int]							=							TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'						)

					_lowercase				,      _lowercase				,      _lowercase				,      _lowercase				,      _lowercase :    Optional[Any]							=							prepare_layoutlm_batch_inputs()

					# forward pass
					_lowercase :    Tuple							=							model(input_ids=lowerCamelCase_			,					bbox=lowerCamelCase_			,					attention_mask=lowerCamelCase_			,					token_type_ids=lowerCamelCase_						)

					# test the shape of the logits
					_lowercase :    Optional[int]							=							tf.convert_to_tensor((2, 2_5)						)
					self.assertEqual(outputs.start_logits.shape			,					lowerCamelCase_						)
					self.assertEqual(outputs.end_logits.shape			,					lowerCamelCase_						)




"""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(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    Optional[int]							=							int(__UpperCAmelCase			)
	_lowercase				,      _lowercase				,      _lowercase :    Union[str, Any]							=							t // 3_600, (t // 60) % 60, t % 60
	return F'''{h}:{m:02d}:{s:02d}''' if h != 0 else F'''{m:02d}:{s:02d}'''


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase     ,__UpperCAmelCase=300			):






	"""simple docstring"""





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


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	_lowercase :    List[Any]							=							'<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:
			_lowercase :    Optional[Any]							=							F'''{elt:.6f}''' if isinstance(__UpperCAmelCase     ,__UpperCAmelCase			) else str(__UpperCAmelCase			)
			html_code += F'''      <td>{elt}</td>\n'''
		html_code += "    </tr>\n"
	html_code += "  </tbody>\n</table><p>"
	return html_code



class  _lowerCamelCase			:
				_snake_case     =  5
				_snake_case     =  0.2







				def __init__( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[str] = None			,					lowerCamelCase_    :       bool = True			,					lowerCamelCase_    :       Optional["NotebookTrainingTracker"] = None			,					lowerCamelCase_    :       int = 3_0_0			,					):

					"""simple docstring"""






					_lowercase :    int							=							total
					_lowercase :    Dict							=							'' if prefix is None else prefix
					_lowercase :    List[Any]							=							leave
					_lowercase :    Dict							=							parent
					_lowercase :    str							=							width
					_lowercase :    Any							=							None
					_lowercase :    Optional[int]							=							None
					_lowercase :    Union[str, Any]							=							None







				def 							__UpperCAmelCase					( self    :       Dict			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       bool = False			,					lowerCamelCase_    :       str = None						):

					"""simple docstring"""






					_lowercase :    Dict							=							value
					if comment is not None:
						_lowercase :    List[str]							=							comment
					if self.last_value is None:
						_lowercase :    List[Any]							=							time.time()
						_lowercase :    str							=							value
						_lowercase :    Any							=							None
						_lowercase :    List[Any]							=							self.warmup
						_lowercase :    Union[str, Any]							=							1
						self.update_bar(lowerCamelCase_						)
					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
						_lowercase :    Tuple							=							time.time()
						_lowercase :    List[str]							=							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:
							_lowercase :    List[Any]							=							self.elapsed_time / (value - self.start_value)
						else:
							_lowercase :    List[Any]							=							None
						if value >= self.total:
							_lowercase :    Optional[Any]							=							self.total
							_lowercase :    str							=							None
							if not self.leave:
								self.close()
						elif self.average_time_per_item is not None:
							_lowercase :    int							=							self.average_time_per_item * (self.total - value)
						self.update_bar(lowerCamelCase_						)
						_lowercase :    Optional[int]							=							value
						_lowercase :    Dict							=							current_time
						if self.average_time_per_item is None:
							_lowercase :    Union[str, Any]							=							1
						else:
							_lowercase :    Optional[Any]							=							max(int(self.update_every / self.average_time_per_item						)			,					1						)







				def 							__UpperCAmelCase					( self    :       str			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       Optional[Any]=None						):

					"""simple docstring"""






					_lowercase :    str							=							' ' * (len(str(self.total						)						) - len(str(lowerCamelCase_						)						)) + str(lowerCamelCase_						)
					if self.elapsed_time is None:
						_lowercase :    Dict							=							F'''[{spaced_value}/{self.total} : < :'''
					elif self.predicted_remaining is None:
						_lowercase :    Optional[int]							=							F'''[{spaced_value}/{self.total} {format_time(self.elapsed_time						)}'''
					else:
						_lowercase :    int							=							(
						    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 							__UpperCAmelCase					( self    :       int						):

					"""simple docstring"""






					_lowercase :    int							=							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:
						_lowercase :    List[str]							=							disp.display(disp.HTML(self.html_code						)			,					display_id=lowerCamelCase_						)
					else:
						self.output.update(disp.HTML(self.html_code						)						)







				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






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



class  _lowerCamelCase			(__lowerCamelCase     ):







				def __init__( self    :       Optional[int]			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Tuple=None						):

					"""simple docstring"""






					super().__init__(lowerCamelCase_						)
					_lowercase :    Tuple							=							None if column_names is None else [column_names]
					_lowercase :    Optional[int]							=							None







				def 							__UpperCAmelCase					( self    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    Union[str, Any]							=							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:
						_lowercase :    Dict							=							disp.display(disp.HTML(self.html_code						)			,					display_id=lowerCamelCase_						)
					else:
						self.output.update(disp.HTML(self.html_code						)						)







				def 							__UpperCAmelCase					( self    :       Optional[Any]			,					lowerCamelCase_    :       Optional[int]						):

					"""simple docstring"""






					if self.inner_table is None:
						_lowercase :    Optional[int]							=							[list(values.keys()						), list(values.values()						)]
					else:
						_lowercase :    str							=							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(lowerCamelCase_						)
							_lowercase :    List[Any]							=							columns
						self.inner_table.append([values[c] for c in columns]						)







				def 							__UpperCAmelCase					( self    :       List[Any]			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       Union[str, Any]=None			,					lowerCamelCase_    :       int=3_0_0						):

					"""simple docstring"""






					_lowercase :    List[str]							=							NotebookProgressBar(lowerCamelCase_			,					prefix=lowerCamelCase_			,					parent=self			,					width=lowerCamelCase_						)
					return self.child_bar







				def 							__UpperCAmelCase					( self    :       Any						):

					"""simple docstring"""






					_lowercase :    Any							=							None
					self.display()



class  _lowerCamelCase			(__lowerCamelCase     ):







				def __init__( self    :       Optional[Any]						):

					"""simple docstring"""






					_lowercase :    int							=							None
					_lowercase :    Any							=							None
					_lowercase :    Optional[int]							=							False







				def 							__UpperCAmelCase					( self    :       Any			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       List[Any]			,					**lowerCamelCase_    :       Union[str, Any]						):

					"""simple docstring"""






					_lowercase :    Any							=							'Epoch' if args.evaluation_strategy == IntervalStrategy.EPOCH else 'Step'
					_lowercase :    Dict							=							0
					_lowercase :    Optional[Any]							=							0
					_lowercase :    Union[str, Any]							=							[self.first_column] + ['Training Loss']
					if args.evaluation_strategy != IntervalStrategy.NO:
						column_names.append('Validation Loss'						)
					_lowercase :    Tuple							=							NotebookTrainingTracker(state.max_steps			,					lowerCamelCase_						)







				def 							__UpperCAmelCase					( self    :       Union[str, Any]			,					lowerCamelCase_    :       Any			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Union[str, Any]			,					**lowerCamelCase_    :       Dict						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							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			,					)
					_lowercase :    Tuple							=							False







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Optional[int]			,					lowerCamelCase_    :       Union[str, Any]=None			,					**lowerCamelCase_    :       str						):

					"""simple docstring"""






					if not has_length(lowerCamelCase_						):
						return
					if self.prediction_bar is None:
						if self.training_tracker is not None:
							_lowercase :    Tuple							=							self.training_tracker.add_child(len(lowerCamelCase_						)						)
						else:
							_lowercase :    Optional[Any]							=							NotebookProgressBar(len(lowerCamelCase_						)						)
						self.prediction_bar.update(1						)
					else:
						self.prediction_bar.update(self.prediction_bar.value + 1						)







				def 							__UpperCAmelCase					( self    :       Tuple			,					lowerCamelCase_    :       Dict			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Dict			,					**lowerCamelCase_    :       List[str]						):

					"""simple docstring"""






					if self.prediction_bar is not None:
						self.prediction_bar.close()
					_lowercase :    Union[str, Any]							=							None







				def 							__UpperCAmelCase					( self    :       List[str]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       str			,					lowerCamelCase_    :       int=None			,					**lowerCamelCase_    :       List[Any]						):

					"""simple docstring"""






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







				def 							__UpperCAmelCase					( self    :       int			,					lowerCamelCase_    :       List[Any]			,					lowerCamelCase_    :       int			,					lowerCamelCase_    :       List[str]			,					lowerCamelCase_    :       str=None			,					**lowerCamelCase_    :       List[Any]						):

					"""simple docstring"""






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

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







				def 							__UpperCAmelCase					( self    :       Optional[int]			,					lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Optional[Any]			,					lowerCamelCase_    :       Union[str, Any]			,					**lowerCamelCase_    :       Any						):

					"""simple docstring"""






					self.training_tracker.update(
					    state.global_step			,					comment=F'''Epoch {int(state.epoch						)}/{state.num_train_epochs}'''			,					force_update=lowerCamelCase_						)
					_lowercase :    List[Any]							=							None



