





from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


_snake_case				= logging.get_logger(__name__)

# General docstring
_snake_case				= """ResNetConfig"""

# Base docstring
_snake_case				= """microsoft/resnet-50"""
_snake_case				= [1, 2048, 7, 7]

# Image classification docstring
_snake_case				= """microsoft/resnet-50"""
_snake_case				= """tiger cat"""

_snake_case				= [
    """microsoft/resnet-50""",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Tuple    ,							_lowercase  :int    ,							_lowercase  :int = 3    ,							_lowercase  :int = 1    ,							_lowercase  :str = "relu"    ,							**_lowercase  :List[Any]					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  kernel_size // 2
     lowercase__    =  tf.keras.layers.ConvaD(
         _lowercase    ,							kernel_size=_lowercase    ,							strides=_lowercase    ,							padding="valid"    ,							use_bias=_lowercase    ,							name="convolution"					)
     # Use same default momentum and epsilon as PyTorch equivalent
     lowercase__    =  tf.keras.layers.BatchNormalization(epsilon=1e-5    ,							momentum=0.9    ,							name="normalization"					)
     lowercase__    =  ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"					)







  def   UpperCAmelCase     (			self  :Optional[int]    ,							_lowercase  :tf.Tensor					):






     '''simple docstring'''





     lowercase__    =  lowercase__    =  (self.pad_value, self.pad_value)
     lowercase__    =  tf.pad(_lowercase    ,							[(0, 0), height_pad, width_pad, (0, 0)]					)
     lowercase__    =  self.conv(_lowercase					)
     return hidden_state







  def   UpperCAmelCase     (			self  :Any    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     lowercase__    =  self.convolution(_lowercase					)
     lowercase__    =  self.normalization(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.activation(_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Tuple    ,							_lowercase  :ResNetConfig    ,							**_lowercase  :Any					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  TFResNetConvLayer(
         config.embedding_size    ,							kernel_size=7    ,							stride=2    ,							activation=config.hidden_act    ,							name="embedder"    ,							)
     lowercase__    =  tf.keras.layers.MaxPoolaD(pool_size=3    ,							strides=2    ,							padding="valid"    ,							name="pooler"					)
     lowercase__    =  config.num_channels







  def   UpperCAmelCase     (			self  :Tuple    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     lowercase__   ,							lowercase__   ,							lowercase__   ,							lowercase__    =  shape_list(_lowercase					)
     if tf.executing_eagerly() and num_channels != self.num_channels:
        raise ValueError(
            "Make sure that the channel dimension of the pixel values match with the one set in the configuration."					)
     lowercase__    =  pixel_values
     lowercase__    =  self.embedder(_lowercase					)
     lowercase__    =  tf.pad(_lowercase    ,							[[0, 0], [1, 1], [1, 1], [0, 0]]					)
     lowercase__    =  self.pooler(_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Optional[int]    ,							_lowercase  :int    ,							_lowercase  :int = 2    ,							**_lowercase  :Dict					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  tf.keras.layers.ConvaD(
         _lowercase    ,							kernel_size=1    ,							strides=_lowercase    ,							use_bias=_lowercase    ,							name="convolution"					)
     # Use same default momentum and epsilon as PyTorch equivalent
     lowercase__    =  tf.keras.layers.BatchNormalization(epsilon=1e-5    ,							momentum=0.9    ,							name="normalization"					)







  def   UpperCAmelCase     (			self  :Optional[Any]    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     lowercase__    =  x
     lowercase__    =  self.convolution(_lowercase					)
     lowercase__    =  self.normalization(_lowercase    ,							training=_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Any    ,							_lowercase  :int    ,							_lowercase  :int    ,							_lowercase  :int = 1    ,							_lowercase  :str = "relu"    ,							**_lowercase  :List[Any]					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  in_channels != out_channels or stride != 1
     lowercase__    =  TFResNetConvLayer(_lowercase    ,							stride=_lowercase    ,							name="layer.0"					)
     lowercase__    =  TFResNetConvLayer(_lowercase    ,							activation=_lowercase    ,							name="layer.1"					)
     lowercase__    =  (
         TFResNetShortCut(_lowercase    ,							stride=_lowercase    ,							name="shortcut"					)
         if should_apply_shortcut
         else tf.keras.layers.Activation("linear"    ,							name="shortcut"					)
     )
     lowercase__    =  ACTaFN[activation]







  def   UpperCAmelCase     (			self  :List[Any]    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     lowercase__    =  hidden_state
     lowercase__    =  self.conva(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.conva(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.shortcut(_lowercase    ,							training=_lowercase					)
     hidden_state += residual
     lowercase__    =  self.activation(_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Dict    ,							_lowercase  :int    ,							_lowercase  :int    ,							_lowercase  :int = 1    ,							_lowercase  :str = "relu"    ,							_lowercase  :int = 4    ,							**_lowercase  :Union[str, Any]    ,							):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  in_channels != out_channels or stride != 1
     lowercase__    =  out_channels // reduction
     lowercase__    =  TFResNetConvLayer(_lowercase    ,							kernel_size=1    ,							name="layer.0"					)
     lowercase__    =  TFResNetConvLayer(_lowercase    ,							stride=_lowercase    ,							name="layer.1"					)
     lowercase__    =  TFResNetConvLayer(_lowercase    ,							kernel_size=1    ,							activation=_lowercase    ,							name="layer.2"					)
     lowercase__    =  (
         TFResNetShortCut(_lowercase    ,							stride=_lowercase    ,							name="shortcut"					)
         if should_apply_shortcut
         else tf.keras.layers.Activation("linear"    ,							name="shortcut"					)
     )
     lowercase__    =  ACTaFN[activation]







  def   UpperCAmelCase     (			self  :int    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     lowercase__    =  hidden_state
     lowercase__    =  self.conva(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.conva(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.conva(_lowercase    ,							training=_lowercase					)
     lowercase__    =  self.shortcut(_lowercase    ,							training=_lowercase					)
     hidden_state += residual
     lowercase__    =  self.activation(_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Union[str, Any]    ,							_lowercase  :ResNetConfig    ,							_lowercase  :int    ,							_lowercase  :int    ,							_lowercase  :int = 2    ,							_lowercase  :int = 2    ,							**_lowercase  :List[str]					):






     '''simple docstring'''





     super().__init__(**_lowercase					)

     lowercase__    =  TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

     lowercase__    =  [layer(_lowercase    ,							_lowercase    ,							stride=_lowercase    ,							activation=config.hidden_act    ,							name="layers.0"					)]
     layers += [
         layer(_lowercase    ,							_lowercase    ,							activation=config.hidden_act    ,							name=f'''layers.{i + 1}'''					)
         for i in range(depth - 1					)
     ]
     lowercase__    =  layers







  def   UpperCAmelCase     (			self  :str    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False					):






     '''simple docstring'''





     for layer in self.stage_layers:
        lowercase__    =  layer(_lowercase    ,							training=_lowercase					)
     return hidden_state





class 					lowerCAmelCase							(   tf.keras.layers.Layer					):







  def __init__(			self  :Tuple    ,							_lowercase  :ResNetConfig    ,							**_lowercase  :Dict					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
     lowercase__    =  [
         TFResNetStage(
             _lowercase    ,							config.embedding_size    ,							config.hidden_sizes[0]    ,							stride=2 if config.downsample_in_first_stage else 1    ,							depth=config.depths[0]    ,							name="stages.0"    ,							)
     ]
     for i, (in_channels, out_channels, depth) in enumerate(
         zip(config.hidden_sizes    ,							config.hidden_sizes[1:]    ,							config.depths[1:]					)					):
        self.stages.append(TFResNetStage(_lowercase    ,							_lowercase    ,							_lowercase    ,							depth=_lowercase    ,							name=f'''stages.{i + 1}'''					)					)







  def   UpperCAmelCase     (			self  :Any    ,							_lowercase  :tf.Tensor    ,							_lowercase  :bool = False    ,							_lowercase  :bool = True    ,							_lowercase  :bool = False    ,							):






     '''simple docstring'''





     lowercase__    =  () if output_hidden_states else None

     for stage_module in self.stages:
        if output_hidden_states:
           lowercase__    =  hidden_states + (hidden_state,)

        lowercase__    =  stage_module(_lowercase    ,							training=_lowercase					)

     if output_hidden_states:
        lowercase__    =  hidden_states + (hidden_state,)

     if not return_dict:
        return tuple(v for v in [hidden_state, hidden_states] if v is not None					)

     return TFBaseModelOutputWithNoAttention(last_hidden_state=_lowercase    ,							hidden_states=_lowercase					)





class 					lowerCAmelCase							(   lowercase_					):
  __lowerCamelCase		=			ResNetConfig
  __lowerCamelCase		=			'resnet'
  __lowerCamelCase		=			'pixel_values'







  @property
  def   UpperCAmelCase     (			self  :int					):






     '''simple docstring'''





     return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)    ,							dtype=tf.floataa					)}
_snake_case				= R"""
    This model is a TensorFlow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular TensorFlow Module and refer to the TensorFlow documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`ResNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""


_snake_case				= R"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConvNextImageProcessor.__call__`] for details.

        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""





@keras_serializable
class 					lowerCAmelCase							(   tf.keras.layers.Layer					):
  __lowerCamelCase		=			ResNetConfig







  def __init__(			self  :Union[str, Any]    ,							_lowercase  :ResNetConfig    ,							**_lowercase  :List[Any]					):






     '''simple docstring'''





     super().__init__(**_lowercase					)
     lowercase__    =  config
     lowercase__    =  TFResNetEmbeddings(_lowercase    ,							name="embedder"					)
     lowercase__    =  TFResNetEncoder(_lowercase    ,							name="encoder"					)
     lowercase__    =  tf.keras.layers.GlobalAveragePoolingaD(keepdims=_lowercase					)







  @unpack_inputs
  def   UpperCAmelCase     (			self  :List[Any]    ,							_lowercase  :tf.Tensor    ,							_lowercase  :Optional[bool] = None    ,							_lowercase  :Optional[bool] = None    ,							_lowercase  :bool = False    ,							):






     '''simple docstring'''





     lowercase__    =  (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     lowercase__    =  return_dict if return_dict is not None else self.config.use_return_dict

     # TF 2.0 image layers can't use NCHW format when running on CPU.
     # We transpose to NHWC format and then transpose back after the full forward pass.
     # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
     lowercase__    =  tf.transpose(_lowercase    ,							perm=[0, 2, 3, 1]					)
     lowercase__    =  self.embedder(_lowercase    ,							training=_lowercase					)

     lowercase__    =  self.encoder(
         _lowercase    ,							output_hidden_states=_lowercase    ,							return_dict=_lowercase    ,							training=_lowercase					)

     lowercase__    =  encoder_outputs[0]

     lowercase__    =  self.pooler(_lowercase					)

     # Transpose all the outputs to the NCHW format
     # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
     lowercase__    =  tf.transpose(_lowercase    ,							(0, 3, 1, 2)					)
     lowercase__    =  tf.transpose(_lowercase    ,							(0, 3, 1, 2)					)
     lowercase__    =  ()
     for hidden_state in encoder_outputs[1:]:
        lowercase__    =  hidden_states + tuple(tf.transpose(_lowercase    ,							(0, 3, 1, 2)					) for h in hidden_state					)

     if not return_dict:
        return (last_hidden_state, pooled_output) + hidden_states

     lowercase__    =  hidden_states if output_hidden_states else None

     return TFBaseModelOutputWithPoolingAndNoAttention(
         last_hidden_state=_lowercase    ,							pooler_output=_lowercase    ,							hidden_states=_lowercase    ,							)





@add_start_docstrings(
    'The bare ResNet model outputting raw features without any specific head on top.'							,							lowercase_							,							)
class 					lowerCAmelCase							(   lowercase_					):







  def __init__(			self  :Any    ,							_lowercase  :ResNetConfig    ,							**_lowercase  :List[str]					):






     '''simple docstring'''





     super().__init__(_lowercase    ,							**_lowercase					)
     lowercase__    =  TFResNetMainLayer(config=_lowercase    ,							name="resnet"					)







  @add_start_docstrings_to_model_forward(_lowercase					)
  @add_code_sample_docstrings(
      checkpoint=_CHECKPOINT_FOR_DOC    ,							output_type=_lowercase    ,							config_class=_CONFIG_FOR_DOC    ,							modality="vision"    ,							expected_output=_EXPECTED_OUTPUT_SHAPE    ,							)
  @unpack_inputs
  def   UpperCAmelCase     (			self  :Union[str, Any]    ,							_lowercase  :tf.Tensor    ,							_lowercase  :Optional[bool] = None    ,							_lowercase  :Optional[bool] = None    ,							_lowercase  :bool = False    ,							):






     '''simple docstring'''





     lowercase__    =  (
         output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
     )
     lowercase__    =  return_dict if return_dict is not None else self.config.use_return_dict

     lowercase__    =  self.resnet(
         pixel_values=_lowercase    ,							output_hidden_states=_lowercase    ,							return_dict=_lowercase    ,							training=_lowercase    ,							)
     return resnet_outputs





@add_start_docstrings(
    '\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '							,							lowercase_							,							)
class 					lowerCAmelCase							(   lowercase_							,							lowercase_					):







  def __init__(			self  :Any    ,							_lowercase  :ResNetConfig    ,							**_lowercase  :List[Any]					):






     '''simple docstring'''





     super().__init__(_lowercase    ,							**_lowercase					)
     lowercase__    =  config.num_labels
     lowercase__    =  TFResNetMainLayer(_lowercase    ,							name="resnet"					)
     # classification head
     lowercase__    =  (
         tf.keras.layers.Dense(config.num_labels    ,							name="classifier.1"					)
         if config.num_labels > 0
         else tf.keras.layers.Activation("linear"    ,							name="classifier.1"					)
     )







  def   UpperCAmelCase     (			self  :Tuple    ,							_lowercase  :tf.Tensor					):






     '''simple docstring'''





     lowercase__    =  tf.keras.layers.Flatten()(_lowercase					)
     lowercase__    =  self.classifier_layer(_lowercase					)
     return logits







  @add_start_docstrings_to_model_forward(_lowercase					)
  @add_code_sample_docstrings(
      checkpoint=_IMAGE_CLASS_CHECKPOINT    ,							output_type=_lowercase    ,							config_class=_CONFIG_FOR_DOC    ,							expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT    ,							)
  @unpack_inputs
  def   UpperCAmelCase     (			self  :str    ,							_lowercase  :tf.Tensor = None    ,							_lowercase  :tf.Tensor = None    ,							_lowercase  :bool = None    ,							_lowercase  :bool = None    ,							_lowercase  :bool = False    ,							):






     '''simple docstring'''





     lowercase__    =  return_dict if return_dict is not None else self.config.use_return_dict

     lowercase__    =  self.resnet(
         _lowercase    ,							output_hidden_states=_lowercase    ,							return_dict=_lowercase    ,							training=_lowercase					)

     lowercase__    =  outputs.pooler_output if return_dict else outputs[1]

     lowercase__    =  self.classifier(_lowercase					)

     lowercase__    =  None if labels is None else self.hf_compute_loss(_lowercase    ,							_lowercase					)

     if not return_dict:
        lowercase__    =  (logits,) + outputs[2:]
        return (loss,) + output if loss is not None else output

     return TFImageClassifierOutputWithNoAttention(loss=_lowercase    ,							logits=_lowercase    ,							hidden_states=outputs.hidden_states					)













import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


_snake_case				= logging.getLogger(__name__)





@dataclass
class 					lowerCAmelCase							:
  __lowerCamelCase		=			field(
      metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}					)
  __lowerCamelCase		=			field(
      default=lowercase_							,							metadata={'help': 'Pretrained config name or path if not the same as model_name'}					)
  __lowerCamelCase		=			field(
      default=lowercase_							,							metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'}					)
  __lowerCamelCase		=			field(default=lowercase_							,							metadata={'help': 'Set this flag to use fast tokenization.'}					)
  # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
  # or just modify its tokenizer_config.json.
  __lowerCamelCase		=			field(
      default=lowercase_							,							metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}							,							)


def _A   (    ):
   # See all possible arguments in src/transformers/training_args.py
   # or by passing the --help flag to this script.
   # We now keep distinct sets of args, for a cleaner separation of concerns.

   lowercase__    =  HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)       )

   if len(sys.argv       ) == 2 and sys.argv[1].endswith(".json"       ):
      # If we pass only one argument to the script and it's the path to a json file,
      # let's parse it to get our arguments.
      lowercase__   ,							lowercase__   ,							lowercase__    =  parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]       )       )
   else:
      lowercase__   ,							lowercase__   ,							lowercase__    =  parser.parse_args_into_dataclasses()

   if (
       os.path.exists(training_args.output_dir       )
       and os.listdir(training_args.output_dir       )
       and training_args.do_train
       and not training_args.overwrite_output_dir
   ):
      raise ValueError(
          f'''Output directory ({training_args.output_dir}) already exists and is not empty. Use'''
          " --overwrite_output_dir to overcome."       )

   # Setup logging
   logging.basicConfig(
       format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"  ,					datefmt="%m/%d/%Y %H:%M:%S"  ,					level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN  ,					)
   logger.warning(
       "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s"  ,					training_args.local_rank  ,					training_args.device  ,					training_args.n_gpu  ,					bool(training_args.local_rank != -1       )  ,					training_args.fpaa  ,					)
   # Set the verbosity to info of the Transformers logger (on main process only):
   if is_main_process(training_args.local_rank       ):
      transformers.utils.logging.set_verbosity_info()
      transformers.utils.logging.enable_default_handler()
      transformers.utils.logging.enable_explicit_format()
   logger.info("Training/evaluation parameters %s"  ,					__magic_name__       )

   # Prepare Question-Answering task
   # Load pretrained model and tokenizer
   #
   # Distributed training:
   # The .from_pretrained methods guarantee that only one local process can concurrently
   # download model & vocab.

   lowercase__    =  AutoConfig.from_pretrained(
       model_args.config_name if model_args.config_name else model_args.model_name_or_path  ,					cache_dir=model_args.cache_dir  ,					)
   lowercase__    =  AutoTokenizer.from_pretrained(
       model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path  ,					cache_dir=model_args.cache_dir  ,					use_fast=__magic_name__  ,					)
   lowercase__    =  AutoModelForQuestionAnswering.from_pretrained(
       model_args.model_name_or_path  ,					from_tf=bool(".ckpt" in model_args.model_name_or_path       )  ,					config=__magic_name__  ,					cache_dir=model_args.cache_dir  ,					)

   # Get datasets
   lowercase__    =  hasattr(model.config  ,					"lang2id"       )
   lowercase__    =  (
       SquadDataset(
           __magic_name__  ,					tokenizer=__magic_name__  ,					is_language_sensitive=__magic_name__  ,					cache_dir=model_args.cache_dir       )
       if training_args.do_train
       else None
   )
   lowercase__    =  (
       SquadDataset(
           __magic_name__  ,					tokenizer=__magic_name__  ,					mode="dev"  ,					is_language_sensitive=__magic_name__  ,					cache_dir=model_args.cache_dir  ,					)
       if training_args.do_eval
       else None
   )

   # Data collator
   lowercase__    =  DataCollatorWithPadding(__magic_name__  ,					pad_to_multiple_of=8       ) if training_args.fpaa else None

   # Initialize our Trainer
   lowercase__    =  Trainer(
       model=__magic_name__  ,					args=__magic_name__  ,					train_dataset=__magic_name__  ,					eval_dataset=__magic_name__  ,					data_collator=__magic_name__  ,					)

   # Training
   if training_args.do_train:
      trainer.train(
          model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path       ) else None       )
      trainer.save_model()
      # For convenience, we also re-save the tokenizer to the same directory,
      # so that you can share your model easily on huggingface.co/models =)
      if trainer.is_world_master():
         tokenizer.save_pretrained(training_args.output_dir       )


def _A   (    __magic_name__       ):
   # For xla_spawn (TPUs)
   main()


if __name__ == "__main__":
  main()






