



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


__A				    =						logging.getLogger(__name__)






@dataclass
class 		lowercase						:






	"""simple docstring"""


	a__      :					str		   =							field(
	    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"})
	a__      :					Optional[str]		   =							field(
	    default=snake_case__ ,    metadata={"help": "Pretrained config name or path if not the same as model_name"})
	a__      :					Optional[str]		   =							field(
	    default=snake_case__ ,    metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"})
	a__      :					bool		   =							field(default=snake_case__ ,    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.
	a__      :					Optional[str]		   =							field(
	    default=snake_case__ ,    metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"} ,    )



def        __a     (    )      -> Tuple:






						'''simple docstring'''



						UpperCAmelCase_=   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.
												UpperCAmelCase_,   UpperCAmelCase_,   UpperCAmelCase_=   parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]				)				)
						else:
												UpperCAmelCase_,   UpperCAmelCase_,   UpperCAmelCase_=   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"""			,lowerCAmelCase_				)

						# 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.

						UpperCAmelCase_=   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			,)
						UpperCAmelCase_=   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=lowerCAmelCase_			,)
						UpperCAmelCase_=   AutoModelForQuestionAnswering.from_pretrained(
						    model_args.model_name_or_path			,from_tf=bool(""".ckpt""" in model_args.model_name_or_path				)			,config=lowerCAmelCase_			,cache_dir=model_args.cache_dir			,)

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

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

						# Initialize our Trainer
						UpperCAmelCase_=   Trainer(
						    model=lowerCAmelCase_			,args=lowerCAmelCase_			,train_dataset=lowerCAmelCase_			,eval_dataset=lowerCAmelCase_			,data_collator=lowerCAmelCase_			,)

						# 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     (    lowerCAmelCase_   :					str				)      -> Optional[int]:






						'''simple docstring'''



						main()


if __name__ == "__main__":
	main()









from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PretrainedConfig, PreTrainedTokenizer
from ...onnx import OnnxConfig, PatchingSpec
from ...utils import TensorType, is_torch_available, logging


__A				    =						logging.get_logger(__name__)

__A				    =						{
    '''microsoft/layoutlm-base-uncased''': (
        '''https://huggingface.co/microsoft/layoutlm-base-uncased/resolve/main/config.json'''
    ),
    '''microsoft/layoutlm-large-uncased''': (
        '''https://huggingface.co/microsoft/layoutlm-large-uncased/resolve/main/config.json'''
    ),
}






class 		lowercase						( snake_case__):






	"""simple docstring"""


	a__      :					Dict		   =							"layoutlm"




	def __init__(	self	:						List[Any]						,  __UpperCAmelCase	:						int=30_522						,  __UpperCAmelCase	:						List[Any]=768						,  __UpperCAmelCase	:						Optional[int]=12						,  __UpperCAmelCase	:						List[str]=12						,  __UpperCAmelCase	:						int=3_072						,  __UpperCAmelCase	:						str="gelu"						,  __UpperCAmelCase	:						str=0.1						,  __UpperCAmelCase	:						Any=0.1						,  __UpperCAmelCase	:						Union[str, Any]=512						,  __UpperCAmelCase	:						Any=2						,  __UpperCAmelCase	:						Any=0.02						,  __UpperCAmelCase	:						Dict=1E-12						,  __UpperCAmelCase	:						Optional[int]=0						,  __UpperCAmelCase	:						List[str]="absolute"						,  __UpperCAmelCase	:						List[Any]=True						,  __UpperCAmelCase	:						Optional[int]=1_024						,  **__UpperCAmelCase	:						int						,  )			-> Union[str, Any]:
							super().__init__(pad_token_id=__UpperCAmelCase						,  **__UpperCAmelCase     )
							UpperCAmelCase_=   vocab_size
							UpperCAmelCase_=   hidden_size
							UpperCAmelCase_=   num_hidden_layers
							UpperCAmelCase_=   num_attention_heads
							UpperCAmelCase_=   hidden_act
							UpperCAmelCase_=   intermediate_size
							UpperCAmelCase_=   hidden_dropout_prob
							UpperCAmelCase_=   attention_probs_dropout_prob
							UpperCAmelCase_=   max_position_embeddings
							UpperCAmelCase_=   type_vocab_size
							UpperCAmelCase_=   initializer_range
							UpperCAmelCase_=   layer_norm_eps
							UpperCAmelCase_=   position_embedding_type
							UpperCAmelCase_=   use_cache
							UpperCAmelCase_=   max_ad_position_embeddings






class 		lowercase						( snake_case__):






	"""simple docstring"""


	def __init__(	self	:						List[str]						,  __UpperCAmelCase	:						PretrainedConfig						,  __UpperCAmelCase	:						str = "default"						,  __UpperCAmelCase	:						List[PatchingSpec] = None						,  )			-> str:
							super().__init__(__UpperCAmelCase						,  task=__UpperCAmelCase						,  patching_specs=__UpperCAmelCase     )
							UpperCAmelCase_=   config.max_ad_position_embeddings - 1




	@property
	def   _SCREAMING_SNAKE_CASE		(	self	:						Optional[Any]     )			-> Mapping[str, Mapping[int, str]]:
							return OrderedDict(
							    [
							        ("""input_ids""", {0: """batch""", 1: """sequence"""}),
							        ("""bbox""", {0: """batch""", 1: """sequence"""}),
							        ("""attention_mask""", {0: """batch""", 1: """sequence"""}),
							        ("""token_type_ids""", {0: """batch""", 1: """sequence"""}),
							    ]     )




	def   _SCREAMING_SNAKE_CASE		(	self	:						Any						,  __UpperCAmelCase	:						PreTrainedTokenizer						,  __UpperCAmelCase	:						int = -1						,  __UpperCAmelCase	:						int = -1						,  __UpperCAmelCase	:						bool = False						,  __UpperCAmelCase	:						Optional[TensorType] = None						,  )			-> Mapping[str, Any]:
							UpperCAmelCase_=   super().generate_dummy_inputs(
							    __UpperCAmelCase						,  batch_size=__UpperCAmelCase						,  seq_length=__UpperCAmelCase						,  is_pair=__UpperCAmelCase						,  framework=__UpperCAmelCase     )

							# Generate a dummy bbox
							UpperCAmelCase_=   [48, 84, 73, 128]

							if not framework == TensorType.PYTORCH:
													raise NotImplementedError("""Exporting LayoutLM to ONNX is currently only supported for PyTorch."""     )

							if not is_torch_available():
													raise ValueError("""Cannot generate dummy inputs without PyTorch installed."""     )
							import torch

							UpperCAmelCase_,   UpperCAmelCase_=   input_dict["""input_ids"""].shape
							UpperCAmelCase_=   torch.tensor([*[box] * seq_length]     ).tile(__UpperCAmelCase						,  1						,  1     )
							return input_dict




