


import json
import os
import unittest

from transformers.models.gptsan_japanese.tokenization_gptsan_japanese import (
    VOCAB_FILES_NAMES,
    GPTSanJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class     snake_case      (							__lowerCAmelCase						,			unittest.TestCase						):
			'''simple docstring'''

			UpperCAmelCase							:							Optional[Any]							=			GPTSanJapaneseTokenizer
			UpperCAmelCase							:							int							=			False
			UpperCAmelCase							:							List[str]							=			{'''do_clean_text''': False, '''add_prefix_space''': False}

			def _lowercase			(						self  :  List[Any]       )       ->       Tuple:




								"""simple docstring"""






								super().setUp()

								# fmt: off
								SCREAMING_SNAKE_CASE_						   =							['''こん''', '''こんに''', '''にちは''', '''ばんは''', '''世界,㔺界''', '''、''', '''。''', '''<BR>''', '''<SP>''', '''<TAB>''', '''<URL>''', '''<EMAIL>''', '''<TEL>''', '''<DATE>''', '''<PRICE>''', '''<BLOCK>''', '''<KIGOU>''', '''<U2000U2BFF>''', '''<|emoji1|>''', '''<unk>''', '''<|bagoftoken|>''', '''<|endoftext|>''']
								# fmt: on
								SCREAMING_SNAKE_CASE_						   =							{'''emoji''': {'''\ud83d\ude00''': '''<|emoji1|>'''}, '''emoji_inv''': {'''<|emoji1|>''': '''\ud83d\ude00'''}}  # 😀
								SCREAMING_SNAKE_CASE_						   =							{'''unk_token''': '''<unk>'''}

								SCREAMING_SNAKE_CASE_						   =							os.path.join(self.tmpdirname				,				VOCAB_FILES_NAMES['''vocab_file''']       )
								SCREAMING_SNAKE_CASE_						   =							os.path.join(self.tmpdirname				,				VOCAB_FILES_NAMES['''emoji_file''']       )
								with open(self.vocab_file				,				'''w'''				,				encoding='''utf-8'''       ) as vocab_writer:
													vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )
								with open(self.emoji_file				,				'''w'''       ) as emoji_writer:
													emoji_writer.write(json.dumps(__SCREAMING_SNAKE_CASE       )       )

			def _lowercase			(						self  :  Any				,				**lowerCAmelCase_  :  Any       )       ->       Any:




								"""simple docstring"""






								kwargs.update(self.special_tokens_map       )
								return GPTSanJapaneseTokenizer.from_pretrained(self.tmpdirname				,				**__SCREAMING_SNAKE_CASE       )

			def _lowercase			(						self  :  Optional[int]				,				lowerCAmelCase_  :  Any       )       ->       Union[str, Any]:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。 \nこんばんは、㔺界。😀'''
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。 \nこんばんは、世界。😀'''
								return input_text, output_text

			def _lowercase			(						self  :  Any				,				lowerCAmelCase_  :  Optional[Any]       )       ->       List[str]:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_   ,SCREAMING_SNAKE_CASE_						   =							self.get_input_output_texts(__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(__SCREAMING_SNAKE_CASE				,				add_special_tokens=__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.decode(__SCREAMING_SNAKE_CASE				,				clean_up_tokenization_spaces=__SCREAMING_SNAKE_CASE       )
								return text, ids

			def _lowercase			(						self  :  Tuple       )       ->       Dict:




								"""simple docstring"""






								pass  # TODO add if relevant

			def _lowercase			(						self  :  Dict       )       ->       str:




								"""simple docstring"""






								pass  # TODO add if relevant

			def _lowercase			(						self  :  Tuple       )       ->       Optional[Any]:




								"""simple docstring"""






								pass  # TODO add if relevant

			def _lowercase			(						self  :  Tuple       )       ->       int:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.get_tokenizer()

								# Testing tokenization
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。　こんばんは、㔺界。'''
								SCREAMING_SNAKE_CASE_						   =							['''こん''', '''にちは''', '''、''', '''世界''', '''。''', '''<SP>''', '''こん''', '''ばんは''', '''、''', '''㔺界''', '''。''']
								SCREAMING_SNAKE_CASE_						   =							tokenizer.tokenize(__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

								# Testing conversion to ids without special tokens
								SCREAMING_SNAKE_CASE_						   =							[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
								SCREAMING_SNAKE_CASE_						   =							tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

								# Testing conversion to ids with special tokens
								SCREAMING_SNAKE_CASE_						   =							tokens + [tokenizer.unk_token]
								SCREAMING_SNAKE_CASE_						   =							[0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
								SCREAMING_SNAKE_CASE_						   =							tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

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




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.get_tokenizer()

								# Testing tokenization
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、<|bagoftoken|>世界。こんばんは、<|bagoftoken|>㔺界。'''
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、、、、世界。こんばんは、、、、世界。'''
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.decode(__SCREAMING_SNAKE_CASE       )
								self.assertEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

			@slow
			def _lowercase			(						self  :  Dict       )       ->       Optional[Any]:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''       )

								# Testing tokenization
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。'''
								SCREAMING_SNAKE_CASE_						   =							'''こんばんは、㔺界。😀'''
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。こんばんは、世界。😀'''
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(prefix_text + input_text       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(''''''				,				prefix_text=prefix_text + input_text       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(__SCREAMING_SNAKE_CASE				,				prefix_text=__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.decode(__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.decode(__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.decode(__SCREAMING_SNAKE_CASE       )
								self.assertEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

			@slow
			def _lowercase			(						self  :  int       )       ->       Tuple:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''       )

								# Testing tokenization
								SCREAMING_SNAKE_CASE_						   =							'''こんにちは、世界。'''
								SCREAMING_SNAKE_CASE_						   =							'''こんばんは、㔺界。😀'''

								SCREAMING_SNAKE_CASE_						   =							len(tokenizer.encode(__SCREAMING_SNAKE_CASE       )       ) - 2
								SCREAMING_SNAKE_CASE_						   =							len(tokenizer.encode(__SCREAMING_SNAKE_CASE       )       ) - 2

								SCREAMING_SNAKE_CASE_						   =							[1] + [0] * (len_prefix + len_text + 1)
								SCREAMING_SNAKE_CASE_						   =							[1] * (len_prefix + len_text + 1) + [0]
								SCREAMING_SNAKE_CASE_						   =							[1] + [1] * (len_prefix) + [0] * (len_text + 1)

								SCREAMING_SNAKE_CASE_						   =							tokenizer(prefix_text + input_text       ).token_type_ids
								SCREAMING_SNAKE_CASE_						   =							tokenizer(''''''				,				prefix_text=prefix_text + input_text       ).token_type_ids
								SCREAMING_SNAKE_CASE_						   =							tokenizer(__SCREAMING_SNAKE_CASE				,				prefix_text=__SCREAMING_SNAKE_CASE       ).token_type_ids
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )

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




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''       )

								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode('''あンいワ'''       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode(''''''				,				prefix_text='''あンいワ'''       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.encode('''いワ'''				,				prefix_text='''あン'''       )

								self.assertEqual(tokenizer.decode(__SCREAMING_SNAKE_CASE       )				,				tokenizer.decode(__SCREAMING_SNAKE_CASE       )       )
								self.assertEqual(tokenizer.decode(__SCREAMING_SNAKE_CASE       )				,				tokenizer.decode(__SCREAMING_SNAKE_CASE       )       )
								self.assertNotEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertNotEqual(__SCREAMING_SNAKE_CASE				,				__SCREAMING_SNAKE_CASE       )
								self.assertEqual(x_token_a[1]				,				x_token_a[-1]       )  # SEG token
								self.assertEqual(x_token_a[1]				,				x_token_a[3]       )  # SEG token

			@slow
			def _lowercase			(						self  :  Dict       )       ->       int:




								"""simple docstring"""






								SCREAMING_SNAKE_CASE_						   =							self.tokenizer_class.from_pretrained('''Tanrei/GPTSAN-japanese'''       )

								SCREAMING_SNAKE_CASE_						   =							[['''武田信玄''', '''は、'''], ['''織田信長''', '''の配下の、''']]
								SCREAMING_SNAKE_CASE_						   =							tokenizer(__SCREAMING_SNAKE_CASE				,				padding=__SCREAMING_SNAKE_CASE       )
								SCREAMING_SNAKE_CASE_						   =							tokenizer.batch_encode_plus(__SCREAMING_SNAKE_CASE				,				padding=__SCREAMING_SNAKE_CASE       )

								# fmt: off
								SCREAMING_SNAKE_CASE_						   =							[[35_993, 8_640, 25_948, 35_998, 30_647, 35_675, 35_999, 35_999], [35_993, 10_382, 9_868, 35_998, 30_646, 9_459, 30_646, 35_675]]
								SCREAMING_SNAKE_CASE_						   =							[[1, 1, 1, 0, 0, 0, 0, 0], [1, 1, 1, 0, 0, 0, 0, 0]]
								SCREAMING_SNAKE_CASE_						   =							[[1, 1, 1, 1, 1, 1, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1]]
								# fmt: on
								self.assertListEqual(x_token.input_ids				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(x_token.token_type_ids				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(x_token.attention_mask				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(x_token_a.input_ids				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(x_token_a.token_type_ids				,				__SCREAMING_SNAKE_CASE       )
								self.assertListEqual(x_token_a.attention_mask				,				__SCREAMING_SNAKE_CASE       )

			def _lowercase			(						self  :  int       )       ->       List[str]:




								"""simple docstring"""






								pass




			def _lowercase			(						self  :  Optional[int]       )       ->       List[Any]:




								"""simple docstring"""






								pass








'''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






