


import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
 from transformers.models.mobilevitva.modeling_mobilevitva import (
     MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
     make_divisible,
 )


if is_vision_available():
 from PIL import Image

 from transformers import MobileViTImageProcessor






class _lowerCamelCase(		_a  ):
       def      UpperCamelCase	(   self)			->  Any:




           """simple docstring"""

           _lowercase			:				Dict 						=						self.config_class(**self.inputs_dict)
           self.parent.assertTrue(hasattr(lowerCamelCase, 'width_multiplier'))






class _lowerCamelCase:
       def __init__(   self, lowerCamelCase, lowerCamelCase=13, lowerCamelCase=64, lowerCamelCase=2, lowerCamelCase=3, lowerCamelCase="swish", lowerCamelCase=3, lowerCamelCase=32, lowerCamelCase=0.1, lowerCamelCase=0.0_2, lowerCamelCase=True, lowerCamelCase=True, lowerCamelCase=10, lowerCamelCase=None, lowerCamelCase=0.2_5, lowerCamelCase=0.0, lowerCamelCase=0.0, )			->  str:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						parent
           _lowercase			:				Optional[Any] 						=						batch_size
           _lowercase			:				List[str] 						=						image_size
           _lowercase			:				Optional[int] 						=						patch_size
           _lowercase			:				str 						=						num_channels
           _lowercase			:				Optional[int] 						=						make_divisible(5_12 * width_multiplier, divisor=8)
           _lowercase			:				Optional[Any] 						=						hidden_act
           _lowercase			:				List[Any] 						=						conv_kernel_size
           _lowercase			:				Any 						=						output_stride
           _lowercase			:				Optional[int] 						=						classifier_dropout_prob
           _lowercase			:				int 						=						use_labels
           _lowercase			:				Any 						=						is_training
           _lowercase			:				Optional[Any] 						=						num_labels
           _lowercase			:				List[Any] 						=						initializer_range
           _lowercase			:				int 						=						scope
           _lowercase			:				Optional[Any] 						=						width_multiplier
           _lowercase			:				List[Any] 						=						ffn_dropout
           _lowercase			:				List[Any] 						=						attn_dropout
       def      UpperCamelCase	(   self)			->  List[Any]:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

           _lowercase			:				Optional[int] 						=						None
           _lowercase			:				int 						=						None
           if self.use_labels:
               _lowercase			:				Any 						=						ids_tensor([self.batch_size], self.num_labels)
               _lowercase			:				List[str] 						=						ids_tensor([self.batch_size, self.image_size, self.image_size], self.num_labels)

           _lowercase			:				List[Any] 						=						self.get_config()

           return config, pixel_values, labels, pixel_labels
       def      UpperCamelCase	(   self)			->  Any:




           """simple docstring"""

           return MobileViTVaConfig(
               image_size=self.image_size, patch_size=self.patch_size, num_channels=self.num_channels, hidden_act=self.hidden_act, conv_kernel_size=self.conv_kernel_size, output_stride=self.output_stride, classifier_dropout_prob=self.classifier_dropout_prob, initializer_range=self.initializer_range, width_multiplier=self.width_multiplier, ffn_dropout=self.ffn_dropout_prob, attn_dropout=self.attn_dropout_prob, )
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						MobileViTVaModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase			:				Tuple 						=						model(lowerCamelCase)
           self.parent.assertEqual(
               result.last_hidden_state.shape, (
                   self.batch_size,
                   self.last_hidden_size,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               ), )
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase)			->  Tuple:




           """simple docstring"""

           _lowercase			:				Dict 						=						self.num_labels
           _lowercase			:				Dict 						=						MobileViTVaForImageClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase			:				Dict 						=						model(lowerCamelCase, labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape, (self.batch_size, self.num_labels))
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase)			->  int:




           """simple docstring"""

           _lowercase			:				List[str] 						=						self.num_labels
           _lowercase			:				Union[str, Any] 						=						MobileViTVaForSemanticSegmentation(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase			:				Union[str, Any] 						=						model(lowerCamelCase)
           self.parent.assertEqual(
               result.logits.shape, (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               ), )
           _lowercase			:				Union[str, Any] 						=						model(lowerCamelCase, labels=lowerCamelCase)
           self.parent.assertEqual(
               result.logits.shape, (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               ), )




       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						self.prepare_config_and_inputs()
           _lowercase						,							_lowercase						,							_lowercase						,							_lowercase			:				List[Any] 						=						config_and_inputs
           _lowercase			:				Any 						=						{'pixel_values': pixel_values}
           return config, inputs_dict






@require_torch
class _lowerCamelCase(		_a,					_a,					unittest.TestCase  ):
       lowercase_					:      int       					=     (
           (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
           if is_torch_available()
           else ()
       )

       lowercase_					:      List[str]       					=     (
           {
               """feature-extraction""": MobileViTVaModel,
               """image-classification""": MobileViTVaForImageClassification,
               """image-segmentation""": MobileViTVaForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       lowercase_					:      Tuple       					=     False
       lowercase_					:      int       					=     False
       lowercase_					:      Union[str, Any]       					=     False
       lowercase_					:      str       					=     False
       def      UpperCamelCase	(   self)			->  Tuple:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						MobileViTVaModelTester(self)
           _lowercase			:				Any 						=						MobileViTVaConfigTester(self, config_class=lowerCamelCase, has_text_modality=lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           self.config_tester.run_common_tests()
       @unittest.skip(reason='MobileViTV2 does not use inputs_embeds')
       def      UpperCamelCase	(   self)			->  Tuple:




           """simple docstring"""

           pass
       @unittest.skip(reason='MobileViTV2 does not support input and output embeddings')
       def      UpperCamelCase	(   self)			->  str:




           """simple docstring"""

           pass
       @unittest.skip(reason='MobileViTV2 does not output attentions')
       def      UpperCamelCase	(   self)			->  Tuple:




           """simple docstring"""

           pass
       @require_torch_multi_gpu
       @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.')
       def      UpperCamelCase	(   self)			->  Tuple:




           """simple docstring"""

           pass
       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
       def      UpperCamelCase	(   self)			->  int:




           """simple docstring"""

           pass
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           _lowercase						,							_lowercase			:				Dict 						=						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               _lowercase			:				str 						=						model_class(lowerCamelCase)
               _lowercase			:				List[str] 						=						inspect.signature(model.forward)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               _lowercase			:				str 						=						[*signature.parameters.keys()]

               _lowercase			:				Union[str, Any] 						=						['pixel_values']
               self.assertListEqual(arg_names[:1], lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				Dict 						=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase)
       def      UpperCamelCase	(   self)			->  int:




           """simple docstring"""

           def check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase):
               _lowercase			:				str 						=						model_class(lowerCamelCase)
               model.to(lowerCamelCase)
               model.eval()

               with torch.no_grad():
                   _lowercase			:				List[Any] 						=						model(**self._prepare_for_class(lowerCamelCase, lowerCamelCase))

               _lowercase			:				Optional[int] 						=						outputs.hidden_states

               _lowercase			:				Dict 						=						5
               self.assertEqual(len(lowerCamelCase), lowerCamelCase)

               # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
               # with the width and height being successively divided by 2.
               _lowercase			:				Dict 						=						2
               for i in range(len(lowerCamelCase)):
                   self.assertListEqual(
                       list(hidden_states[i].shape[-2:]), [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor], )
                   divisor *= 2

               self.assertEqual(self.model_tester.output_stride, divisor // 2)

           _lowercase						,							_lowercase			:				List[Any] 						=						self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               _lowercase			:				Tuple 						=						True
               check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               _lowercase			:				Any 						=						True

               check_hidden_states_output(lowerCamelCase, lowerCamelCase, lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Optional[Any]:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase)
       def      UpperCamelCase	(   self)			->  Dict:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase)




       @slow
       def      UpperCamelCase	(   self)			->  Any:




           """simple docstring"""

           for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase			:				Union[str, Any] 						=						MobileViTVaModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)



def 							UpperCamelCase_( )       ->		Optional[int]:
    _lowercase			:				Optional[int] 						=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'					)
    return image






@require_torch
@require_vision
class _lowerCamelCase(		unittest.TestCase  ):
       @cached_property
       def      UpperCamelCase	(   self)			->  Union[str, Any]:




           """simple docstring"""

           return (
               MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256')
               if is_vision_available()
               else None
           )
       @slow
       def      UpperCamelCase	(   self)			->  Optional[int]:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to(
               lowerCamelCase)

           _lowercase			:				List[Any] 						=						self.default_image_processor
           _lowercase			:				Dict 						=						prepare_img()
           _lowercase			:				Any 						=						image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase			:				Union[str, Any] 						=						model(**lowerCamelCase)

           # verify the logits
           _lowercase			:				List[str] 						=						torch.Size((1, 10_00))
           self.assertEqual(outputs.logits.shape, lowerCamelCase)

           _lowercase			:				Dict 						=						torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase)

           self.assertTrue(torch.allclose(outputs.logits[0, :3], lowerCamelCase, atol=1E-4))
       @slow
       def      UpperCamelCase	(   self)			->  List[Any]:




           """simple docstring"""

           _lowercase			:				List[Any] 						=						MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')
           _lowercase			:				Optional[int] 						=						model.to(lowerCamelCase)

           _lowercase			:				Optional[int] 						=						MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')

           _lowercase			:				List[Any] 						=						prepare_img()
           _lowercase			:				Union[str, Any] 						=						image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase			:				List[str] 						=						model(**lowerCamelCase)
           _lowercase			:				Union[str, Any] 						=						outputs.logits

           # verify the logits
           _lowercase			:				List[Any] 						=						torch.Size((1, 21, 32, 32))
           self.assertEqual(logits.shape, lowerCamelCase)

           _lowercase			:				Dict 						=						torch.tensor(
               [
                   [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
                   [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
                   [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
               ], device=lowerCamelCase, )

           self.assertTrue(torch.allclose(logits[0, :3, :3, :3], lowerCamelCase, atol=1E-4))




       @slow
       def      UpperCamelCase	(   self)			->  List[str]:




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')
           _lowercase			:				List[str] 						=						model.to(lowerCamelCase)

           _lowercase			:				Optional[int] 						=						MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')

           _lowercase			:				List[str] 						=						prepare_img()
           _lowercase			:				List[str] 						=						image_processor(images=lowerCamelCase, return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase			:				Union[str, Any] 						=						model(**lowerCamelCase)

           _lowercase			:				Any 						=						outputs.logits.detach().cpu()

           _lowercase			:				Optional[Any] 						=						image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase, target_sizes=[(50, 60)])
           _lowercase			:				Optional[Any] 						=						torch.Size((50, 60))
           self.assertEqual(segmentation[0].shape, lowerCamelCase)

           _lowercase			:				List[str] 						=						image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase)
           _lowercase			:				Any 						=						torch.Size((32, 32))
           self.assertEqual(segmentation[0].shape, lowerCamelCase)






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_					)       ->		int:
    _lowercase			:				List[str] 						=						int(lowerCamelCase_					)
    _lowercase						,							_lowercase						,							_lowercase			:				Optional[Any] 						=						t // 3600, (t // 60) % 60, t % 60
    return F'''{h}:{m:02d}:{s:02d}''' if h != 0 else F'''{m:02d}:{s:02d}'''



def 							UpperCamelCase_( lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_				,					lowerCamelCase_=300					)       ->		Dict:
    # docstyle-ignore
    return F'''
    <div>
      {prefix}
      <progress value=\'{value}\' max=\'{total}\' style=\'width:{width}px; height:20px; vertical-align: middle;\'></progress>
      {label}
    </div>
    '''



def 							UpperCamelCase_( lowerCamelCase_					)       ->		Any:
    _lowercase			:				int 						=						'<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			:				Any 						=						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_					:      str       					=     0.2
       def __init__(   self, lowerCamelCase, lowerCamelCase = None, lowerCamelCase = True, lowerCamelCase = None, lowerCamelCase = 3_00, )			->  Optional[Any]:




           """simple docstring"""

           _lowercase			:				Optional[int] 						=						total
           _lowercase			:				Optional[int] 						=						'' if prefix is None else prefix
           _lowercase			:				Tuple 						=						leave
           _lowercase			:				str 						=						parent
           _lowercase			:				str 						=						width
           _lowercase			:				List[Any] 						=						None
           _lowercase			:				List[str] 						=						None
           _lowercase			:				Tuple 						=						None
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase = False, lowerCamelCase = None)			->  Dict:




           """simple docstring"""

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




           """simple docstring"""

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




           """simple docstring"""

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




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




           """simple docstring"""

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






class _lowerCamelCase(		_a  ):
       def __init__(   self, lowerCamelCase, lowerCamelCase=None)			->  int:




           """simple docstring"""

           super().__init__(lowerCamelCase)
           _lowercase			:				Optional[Any] 						=						None if column_names is None else [column_names]
           _lowercase			:				Any 						=						None
       def      UpperCamelCase	(   self)			->  List[Any]:




           """simple docstring"""

           _lowercase			:				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, lowerCamelCase)			->  Dict:




           """simple docstring"""

           if self.inner_table is None:
               _lowercase			:				Dict 						=						[list(values.keys()), list(values.values())]
           else:
               _lowercase			:				Tuple 						=						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			:				str 						=						columns
               self.inner_table.append([values[c] for c in columns])
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase=None, lowerCamelCase=3_00)			->  Union[str, Any]:




           """simple docstring"""

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




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




           """simple docstring"""

           _lowercase			:				Optional[Any] 						=						None
           self.display()






class _lowerCamelCase(		_a  ):
       def __init__(   self)			->  List[Any]:




           """simple docstring"""

           _lowercase			:				Union[str, Any] 						=						None
           _lowercase			:				Dict 						=						None
           _lowercase			:				Dict 						=						False
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase)			->  Dict:




           """simple docstring"""

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




           """simple docstring"""

           _lowercase			:				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			:				str 						=						False
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase)			->  Any:




           """simple docstring"""

           if not has_length(lowerCamelCase):
               return
           if self.prediction_bar is None:
               if self.training_tracker is not None:
                   _lowercase			:				Optional[int] 						=						self.training_tracker.add_child(len(lowerCamelCase))
               else:
                   _lowercase			:				Optional[int] 						=						NotebookProgressBar(len(lowerCamelCase))
               self.prediction_bar.update(1)
           else:
               self.prediction_bar.update(self.prediction_bar.value + 1)
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase)			->  Optional[int]:




           """simple docstring"""

           if self.prediction_bar is not None:
               self.prediction_bar.close()
           _lowercase			:				Any 						=						None
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase)			->  List[Any]:




           """simple docstring"""

           if args.evaluation_strategy == IntervalStrategy.NO and "loss" in logs:
               _lowercase			:				Dict 						=						{'Training Loss': logs['loss']}
               # First column is necessarily Step sine we're not in epoch eval strategy
               _lowercase			:				List[Any] 						=						state.global_step
               self.training_tracker.write_line(lowerCamelCase)
       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, lowerCamelCase=None, **lowerCamelCase)			->  List[str]:




           """simple docstring"""

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

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




       def      UpperCamelCase	(   self, lowerCamelCase, lowerCamelCase, lowerCamelCase, **lowerCamelCase)			->  Union[str, Any]:




           """simple docstring"""

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


