
import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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 torch import nn

			from transformers import (
			    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
			    TimesformerForVideoClassification,
			    TimesformerModel,
			)
			from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from transformers import VideoMAEImageProcessor




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	def __init__(  self     :   List[Any]      ,  lowercase     :   Optional[int]      ,  lowercase     :   List[Any]=13      ,  lowercase     :   Any=10      ,  lowercase     :   List[Any]=3      ,  lowercase     :   int=2      ,  lowercase     :   Optional[int]=2      ,  lowercase     :   Union[str, Any]=True      ,  lowercase     :   int=True      ,  lowercase     :   Tuple=32      ,  lowercase     :   List[str]=5      ,  lowercase     :   str=4      ,  lowercase     :   Optional[int]=37      ,  lowercase     :   Optional[Any]="gelu"      ,  lowercase     :   int=0.1      ,  lowercase     :   int=0.1      ,  lowercase     :   Any=10      ,  lowercase     :   List[Any]=0.02      ,  lowercase     :   Dict="divided_space_time"      ,  lowercase     :   Tuple=None      ,  ):


				'''simple docstring'''


				_snake_case          =      parent
				_snake_case          =      batch_size
				_snake_case          =      image_size
				_snake_case          =      num_channels
				_snake_case          =      patch_size
				_snake_case          =      num_frames
				_snake_case          =      is_training
				_snake_case          =      use_labels
				_snake_case          =      hidden_size
				_snake_case          =      num_hidden_layers
				_snake_case          =      num_attention_heads
				_snake_case          =      intermediate_size
				_snake_case          =      hidden_act
				_snake_case          =      hidden_dropout_prob
				_snake_case          =      attention_probs_dropout_prob
				_snake_case          =      attention_type
				_snake_case          =      initializer_range
				_snake_case          =      scope
				_snake_case          =      num_labels

				# in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
				_snake_case          =      (image_size // patch_size) ** 2
				_snake_case          =      (num_frames) * self.num_patches_per_frame + 1



	def 			A							(  self     :   int     ):


				'''simple docstring'''


				_snake_case          =      floats_tensor(
				    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]     )

				_snake_case          =      None
				if self.use_labels:
							_snake_case          =      ids_tensor([self.batch_size]      ,  self.num_labels     )

				_snake_case          =      self.get_config()

				return config, pixel_values, labels



	def 			A							(  self     :   Any     ):


				'''simple docstring'''


				_snake_case          =      TimesformerConfig(
				    image_size=self.image_size      ,  patch_size=self.patch_size      ,  num_channels=self.num_channels      ,  num_frames=self.num_frames      ,  hidden_size=self.hidden_size      ,  num_hidden_layers=self.num_hidden_layers      ,  num_attention_heads=self.num_attention_heads      ,  intermediate_size=self.intermediate_size      ,  hidden_act=self.hidden_act      ,  hidden_dropout_prob=self.hidden_dropout_prob      ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,  initializer_range=self.initializer_range      ,  attention_type=self.attention_type      ,  )
				_snake_case          =      self.num_labels
				return config



	def 			A							(  self     :   Optional[Any]      ,  lowercase     :   int      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      TimesformerModel(config=lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase     )
				self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)     )



	def 			A							(  self     :   Optional[int]      ,  lowercase     :   Optional[Any]      ,  lowercase     :   Dict      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      TimesformerForVideoClassification(lowercase     )
				model.to(lowercase     )
				model.eval()

				_snake_case          =      model(lowercase     )

				# verify the logits shape
				_snake_case          =      torch.Size((self.batch_size, self.num_labels)     )
				self.parent.assertEqual(result.logits.shape      ,  lowercase     )





	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				_snake_case          =      self.prepare_config_and_inputs()
				_snake_case     , _snake_case     , _snake_case          =      config_and_inputs
				_snake_case          =      {'pixel_values': pixel_values}
				return config, inputs_dict




@require_torch
class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase							,UpperCAmelCase							,unittest.TestCase ):





	'''simple docstring'''



	_UpperCAmelCase	:		Dict          = (TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
	_UpperCAmelCase	:		Tuple          = (
	    {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
	    if is_torch_available()
	    else {}
	)

	_UpperCAmelCase	:		str          = False
	_UpperCAmelCase	:		Tuple          = False
	_UpperCAmelCase	:		Optional[Any]          = False
	_UpperCAmelCase	:		Dict          = False



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      TimesformerModelTester(self     )
				_snake_case          =      ConfigTester(
				    self      ,  config_class=lowercase      ,  has_text_modality=lowercase      ,  hidden_size=37     )



	def 			A							(  self     :   int      ,  lowercase     :   Tuple      ,  lowercase     :   Any      ,  lowercase     :   Tuple=False     ):


				'''simple docstring'''


				_snake_case          =      copy.deepcopy(lowercase     )

				if return_labels:
							if model_class in get_values(lowercase     ):
										_snake_case          =      torch.zeros(
										    self.model_tester.batch_size      ,  dtype=torch.long      ,  device=lowercase     )

				return inputs_dict



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				self.config_tester.run_common_tests()



	@unittest.skip(reason='TimeSformer does not use inputs_embeds'     )
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				pass



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							_snake_case          =      model_class(lowercase     )
							self.assertIsInstance(model.get_input_embeddings()      ,  (nn.Module)     )
							_snake_case          =      model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(lowercase      ,  nn.Linear     )     )



	def 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

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

							_snake_case          =      ['pixel_values']
							self.assertListEqual(arg_names[:1]      ,  lowercase     )



	def 			A							(  self     :   Any     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowercase     )



	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_video_classification(*lowercase     )



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


				'''simple docstring'''


				for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							_snake_case          =      TimesformerModel.from_pretrained(lowercase     )
							self.assertIsNotNone(lowercase     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				if not self.has_attentions:
							pass

				else:
							_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()
							_snake_case          =      True

							for model_class in self.all_model_classes:
										_snake_case          =      self.model_tester.seq_length
										_snake_case          =      self.model_tester.num_frames

										_snake_case          =      True
										_snake_case          =      False
										_snake_case          =      True
										_snake_case          =      model_class(lowercase     )
										model.to(lowercase     )
										model.eval()
										with torch.no_grad():
													_snake_case          =      model(**self._prepare_for_class(lowercase      ,  lowercase     )     )
										_snake_case          =      outputs.attentions
										self.assertEqual(len(lowercase     )      ,  self.model_tester.num_hidden_layers     )

										# check that output_attentions also work using config
										del inputs_dict["output_attentions"]
										_snake_case          =      True
										_snake_case          =      model_class(lowercase     )
										model.to(lowercase     )
										model.eval()
										with torch.no_grad():
													_snake_case          =      model(**self._prepare_for_class(lowercase      ,  lowercase     )     )
										_snake_case          =      outputs.attentions
										self.assertEqual(len(lowercase     )      ,  self.model_tester.num_hidden_layers     )

										# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
										self.assertListEqual(
										    list(attentions[0].shape[-3:]     )      ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]      ,  )
										_snake_case          =      len(lowercase     )

										# Check attention is always last and order is fine
										_snake_case          =      True
										_snake_case          =      True
										_snake_case          =      model_class(lowercase     )
										model.to(lowercase     )
										model.eval()
										with torch.no_grad():
													_snake_case          =      model(**self._prepare_for_class(lowercase      ,  lowercase     )     )

										self.assertEqual(out_len + 1      ,  len(lowercase     )     )

										_snake_case          =      outputs.attentions

										self.assertEqual(len(lowercase     )      ,  self.model_tester.num_hidden_layers     )

										# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
										self.assertListEqual(
										    list(self_attentions[0].shape[-3:]     )      ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1]      ,  )





	def 			A							(  self     :   str     ):


				'''simple docstring'''


				def check_hidden_states_output(lowercase     :   Union[str, Any]      ,  lowercase     :   str      ,  lowercase     :   Tuple     ):
							_snake_case          =      model_class(lowercase     )
							model.to(lowercase     )
							model.eval()

							with torch.no_grad():
										_snake_case          =      model(**self._prepare_for_class(lowercase      ,  lowercase     )     )

							_snake_case          =      outputs.hidden_states
							_snake_case          =      self.model_tester.num_hidden_layers + 1
							self.assertEqual(len(lowercase     )      ,  lowercase     )

							_snake_case          =      self.model_tester.seq_length

							self.assertListEqual(
							    list(hidden_states[0].shape[-2:]     )      ,  [seq_length, self.model_tester.hidden_size]      ,  )

				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							_snake_case          =      True
							check_hidden_states_output(lowercase      ,  lowercase      ,  lowercase     )

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							_snake_case          =      True

							check_hidden_states_output(lowercase      ,  lowercase      ,  lowercase     )






def 	a_		(	)			->  List[Any]:
			_snake_case          =      hf_hub_download(
			    repo_id='hf-internal-testing/spaghetti-video'	, filename='eating_spaghetti.npy'	, repo_type='dataset'			)
			_snake_case          =      np.load(__lowercase			)
			return list(__lowercase			)




@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE__					(     unittest.TestCase ):





	'''simple docstring'''



	@cached_property
	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				return (
				    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5]      ,  image_std=[0.5, 0.5, 0.5]     )
				    if is_vision_available()
				    else None
				)





	@slow
	def 			A							(  self     :   int     ):


				'''simple docstring'''


				_snake_case          =      TimesformerForVideoClassification.from_pretrained('facebook/timesformer-base-finetuned-k400'     ).to(
				    lowercase     )

				_snake_case          =      self.default_image_processor
				_snake_case          =      prepare_video()
				_snake_case          =      image_processor(video[:8]      ,  return_tensors='pt'     ).to(lowercase     )

				# forward pass
				with torch.no_grad():
							_snake_case          =      model(**lowercase     )

				# verify the logits
				_snake_case          =      torch.Size((1, 400)     )
				self.assertEqual(outputs.logits.shape      ,  lowercase     )

				_snake_case          =      torch.tensor([-0.3016, -0.7713, -0.4205]     ).to(lowercase     )

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

import logging
import os
import sys
from dataclasses import dataclass, field
from importlib import import_module
from typing import Dict, List, Optional, Tuple

import numpy as np
from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score
from torch import nn
from utils_ner import Split, TokenClassificationDataset, TokenClassificationTask

import transformers
from transformers import (
    AutoConfig,
    AutoModelForTokenClassification,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


_lowerCamelCase	:    int          =      logging.getLogger(__name__)




@dataclass
class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	_UpperCAmelCase	:		str          = field(
	    metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"} )
	_UpperCAmelCase	:		Optional[str]          = field(
	    default=UpperCAmelCase							,metadata={"help": "Pretrained config name or path if not the same as model_name"} )
	_UpperCAmelCase	:		Optional[str]          = field(
	    default="NER"							,metadata={"help": "Task type to fine tune in training (e.g. NER, POS, etc)"} )
	_UpperCAmelCase	:		Optional[str]          = field(
	    default=UpperCAmelCase							,metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"} )
	_UpperCAmelCase	:		bool          = field(default=UpperCAmelCase							,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.
	_UpperCAmelCase	:		Optional[str]          = field(
	    default=UpperCAmelCase							,metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}							,)




@dataclass
class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	_UpperCAmelCase	:		str          = field(
	    metadata={"help": "The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task."} )
	_UpperCAmelCase	:		Optional[str]          = field(
	    default=UpperCAmelCase							,metadata={"help": "Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."}							,)
	_UpperCAmelCase	:		int          = field(
	    default=1_2_8							,metadata={
	        "help": (
	            "The maximum total input sequence length after tokenization. Sequences longer "
	            "than this will be truncated, sequences shorter will be padded."
	        )
	    }							,)
	_UpperCAmelCase	:		bool          = field(
	    default=UpperCAmelCase							,metadata={"help": "Overwrite the cached training and evaluation sets"} )






def 	a_		(	)			->  Optional[int]:
			# 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.

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

			_snake_case          =      import_module('tasks'			)
			try:
						_snake_case          =      getattr(__lowercase	, model_args.task_type			)
						_snake_case          =      token_classification_task_clazz()
			except AttributeError:
						raise ValueError(
						    f'''Task {model_args.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '''
						    f'''Available tasks classes are: {TokenClassificationTask.__subclasses__()}'''			)

			# 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'	, __lowercase			)

			# Set seed
			set_seed(training_args.seed			)

			# Prepare CONLL-2003 task
			_snake_case          =      token_classification_task.get_labels(data_args.labels			)
			_snake_case          =      dict(enumerate(__lowercase			)			)
			_snake_case          =      len(__lowercase			)

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

			_snake_case          =      AutoConfig.from_pretrained(
			    model_args.config_name if model_args.config_name else model_args.model_name_or_path	, num_labels=__lowercase	, idalabel=__lowercase	, labelaid={label: i for i, label in enumerate(__lowercase			)}	, cache_dir=model_args.cache_dir	, )
			_snake_case          =      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=model_args.use_fast	, )
			_snake_case          =      AutoModelForTokenClassification.from_pretrained(
			    model_args.model_name_or_path	, from_tf=bool('.ckpt' in model_args.model_name_or_path			)	, config=__lowercase	, cache_dir=model_args.cache_dir	, )

			# Get datasets
			_snake_case          =      (
			    TokenClassificationDataset(
			        token_classification_task=__lowercase	, data_dir=data_args.data_dir	, tokenizer=__lowercase	, labels=__lowercase	, model_type=config.model_type	, max_seq_length=data_args.max_seq_length	, overwrite_cache=data_args.overwrite_cache	, mode=Split.train	, )
			    if training_args.do_train
			    else None
			)
			_snake_case          =      (
			    TokenClassificationDataset(
			        token_classification_task=__lowercase	, data_dir=data_args.data_dir	, tokenizer=__lowercase	, labels=__lowercase	, model_type=config.model_type	, max_seq_length=data_args.max_seq_length	, overwrite_cache=data_args.overwrite_cache	, mode=Split.dev	, )
			    if training_args.do_eval
			    else None
			)

			def align_predictions(__lowercase       :     np.ndarray	, __lowercase       :     np.ndarray			) -> Tuple[List[int], List[int]]:
						_snake_case          =      np.argmax(__lowercase	, axis=2			)

						_snake_case     , _snake_case          =      preds.shape

						_snake_case          =      [[] for _ in range(__lowercase			)]
						_snake_case          =      [[] for _ in range(__lowercase			)]

						for i in range(__lowercase			):
									for j in range(__lowercase			):
												if label_ids[i, j] != nn.CrossEntropyLoss().ignore_index:
															out_label_list[i].append(label_map[label_ids[i][j]]			)
															preds_list[i].append(label_map[preds[i][j]]			)

						return preds_list, out_label_list

			def compute_metrics(__lowercase       :     EvalPrediction			) -> Dict:
						_snake_case     , _snake_case          =      align_predictions(p.predictions	, p.label_ids			)
						return {
						    "accuracy_score": accuracy_score(__lowercase	, __lowercase			),
						    "precision": precision_score(__lowercase	, __lowercase			),
						    "recall": recall_score(__lowercase	, __lowercase			),
						    "f1": fa_score(__lowercase	, __lowercase			),
						}

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

			# Initialize our Trainer
			_snake_case          =      Trainer(
			    model=__lowercase	, args=__lowercase	, train_dataset=__lowercase	, eval_dataset=__lowercase	, compute_metrics=__lowercase	, data_collator=__lowercase	, )

			# 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_process_zero():
									tokenizer.save_pretrained(training_args.output_dir			)

    # Evaluation
			_snake_case          =      {}
			if training_args.do_eval:
						logger.info('*** Evaluate ***'			)

						_snake_case          =      trainer.evaluate()

						_snake_case          =      os.path.join(training_args.output_dir	, 'eval_results.txt'			)
						if trainer.is_world_process_zero():
									with open(__lowercase	, 'w'			) as writer:
												logger.info('***** Eval results *****'			)
												for key, value in result.items():
															logger.info('  %s = %s'	, __lowercase	, __lowercase			)
															writer.write('%s = %s\n' % (key, value)			)

									results.update(__lowercase			)

    # Predict
			if training_args.do_predict:
						_snake_case          =      TokenClassificationDataset(
						    token_classification_task=__lowercase	, data_dir=data_args.data_dir	, tokenizer=__lowercase	, labels=__lowercase	, model_type=config.model_type	, max_seq_length=data_args.max_seq_length	, overwrite_cache=data_args.overwrite_cache	, mode=Split.test	, )

						_snake_case     , _snake_case     , _snake_case          =      trainer.predict(__lowercase			)
						_snake_case     , _snake_case          =      align_predictions(__lowercase	, __lowercase			)

						_snake_case          =      os.path.join(training_args.output_dir	, 'test_results.txt'			)
						if trainer.is_world_process_zero():
									with open(__lowercase	, 'w'			) as writer:
												for key, value in metrics.items():
															logger.info('  %s = %s'	, __lowercase	, __lowercase			)
															writer.write('%s = %s\n' % (key, value)			)

        # Save predictions
						_snake_case          =      os.path.join(training_args.output_dir	, 'test_predictions.txt'			)
						if trainer.is_world_process_zero():
									with open(__lowercase	, 'w'			) as writer:
												with open(os.path.join(data_args.data_dir	, 'test.txt'			)	, 'r'			) as f:
															token_classification_task.write_predictions_to_file(__lowercase	, __lowercase	, __lowercase			)

			return results






def 	a_		(	__lowercase       :     Optional[Any]			)			->  Optional[int]:
			# For xla_spawn (TPUs)
			main()


if __name__ == "__main__":
			main()