code: 
  
  
  """simple docstring"""
  
  
  
  
  import logging
  import os
  from dataclasses import dataclass, field
  from typing import Dict, List, Optional
  
  import numpy as np
  import torch
  from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels
  
  import transformers
  from transformers import (
      AutoConfig,
      AutoModelForSequenceClassification,
      AutoTokenizer,
      HfArgumentParser,
      Trainer,
      TrainingArguments,
      default_data_collator,
      set_seed,
  )
  from transformers.trainer_utils import is_main_process
  
  
  __magic_name__	:   Dict          =							logging.getLogger(__name__)
  
  
  
  
  @dataclass
  class  __snake_case      :
  							__a				   =					field(
  							    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}     )
  							__a				   =					field(
  							    default=lowerCamelCase ,		metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}     )
  							__a				   =					field(
  							    default=lowerCamelCase ,		metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}     )
  							__a				   =					field(
  							    default=lowerCamelCase ,		metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} ,		)
  
  
  
  
  @dataclass
  class  __snake_case      :
  							__a				   =					field(
  							    metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()     )}     )
  							__a				   =					field(
  							    metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}     )
  							__a				   =					field(
  							    default=128 ,		metadata={
  							        '''help''': (
  							            '''The maximum total input sequence length after tokenization. Sequences longer '''
  							            '''than this will be truncated, sequences shorter will be padded.'''
  							        )
  							    } ,		)
  							__a				   =					field(
  							    default=lowerCamelCase ,		metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}     )
  
  
  
  
  
  def 			a_   (  lowercase__   :List[InputFeatures]    ):
  			__lowerCamelCase        =			default_data_collator(lowercase__    )
  			__lowerCamelCase        =			batch.pop("""pairID""", lowercase__    )
  			return batch
  
  
  
  
  
  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.
  
  			__lowerCamelCase        =			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)    )
  			__lowerCamelCase    ,__lowerCamelCase    ,__lowerCamelCase        =			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""", lowercase__    )
  
  			# Set seed
  			set_seed(training_args.seed    )
  
  			try:
  						__lowerCamelCase        =			hans_tasks_num_labels[data_args.task_name]
  			except KeyError:
  						raise ValueError("""Task not found: %s""" % (data_args.task_name)    )
  
  			# Load pretrained model and tokenizer
  			#
  			# Distributed training:
  			# The .from_pretrained methods guarantee that only one local process can concurrently
  			# download model & vocab.
  
  			__lowerCamelCase        =			AutoConfig.from_pretrained(
  			    model_args.config_name if model_args.config_name else model_args.model_name_or_path, num_labels=lowercase__, finetuning_task=data_args.task_name, cache_dir=model_args.cache_dir, )
  			__lowerCamelCase        =			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, )
  			__lowerCamelCase        =			AutoModelForSequenceClassification.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
  			__lowerCamelCase        =			(
  			    HansDataset(
  			        data_dir=data_args.data_dir, tokenizer=lowercase__, task=data_args.task_name, max_seq_length=data_args.max_seq_length, overwrite_cache=data_args.overwrite_cache, )
  			    if training_args.do_train
  			    else None
  			)
  			__lowerCamelCase        =			(
  			    HansDataset(
  			        data_dir=data_args.data_dir, tokenizer=lowercase__, task=data_args.task_name, max_seq_length=data_args.max_seq_length, overwrite_cache=data_args.overwrite_cache, evaluate=lowercase__, )
  			    if training_args.do_eval
  			    else None
  			)
  
  			# Initialize our Trainer
  			__lowerCamelCase        =			Trainer(
  			    model=lowercase__, args=lowercase__, train_dataset=lowercase__, eval_dataset=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_master():
  									tokenizer.save_pretrained(training_args.output_dir    )
  
      # Evaluation
  			if training_args.do_eval:
  						logger.info("""*** Evaluate ***"""    )
  
  						__lowerCamelCase        =			trainer.predict(lowercase__    )
  						__lowerCamelCase        =			output.predictions
  						__lowerCamelCase        =			np.argmax(lowercase__, axis=1    )
  
  						__lowerCamelCase        =			[ex.pairID for ex in eval_dataset]
  						__lowerCamelCase        =			os.path.join(training_args.output_dir, """hans_predictions.txt"""    )
  						__lowerCamelCase        =			eval_dataset.get_labels()
  						if trainer.is_world_master():
  									with open(lowercase__, """w"""    ) as writer:
  												writer.write("""pairID,gold_label\n"""    )
  												for pid, pred in zip(lowercase__, lowercase__    ):
  															writer.write("""ex""" + str(lowercase__    ) + """,""" + label_list[int(lowercase__    )] + """\n"""    )
  
  						trainer._log(output.metrics    )
  
  
  
  
  
  def 			a_   (  lowercase__   :Dict    ):
  			# For xla_spawn (TPUs)
  			main()
  
  
  if __name__ == "__main__":
  					main()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import os
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			os.path.dirname(os.path.realpath(lowercase__    )    )
  			__lowerCamelCase        =			os.path.join(lowercase__, """triangle.txt"""    )
  
  			with open(lowercase__    ) as in_file:
  						__lowerCamelCase        =			[[int(lowercase__    ) for i in line.split()] for line in in_file]
  
  			while len(lowercase__    ) != 1:
  						__lowerCamelCase        =			triangle.pop()
  						__lowerCamelCase        =			triangle[-1]
  						for j in range(len(lowercase__    ) - 1    ):
  									curr_row[j] += max(last_row[j], last_row[j + 1]    )
  			return triangle[0][0]
  
  
  if __name__ == "__main__":
  					print(solution())
  
  
  
  
  