code: 
  
  
  
  
  
  import logging
  import os
  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 classification_report, fa_score, precision_score, recall_score
  from utils_ner import Split, TFTokenClassificationDataset, TokenClassificationTask
  
  from transformers import (
      AutoConfig,
      AutoTokenizer,
      EvalPrediction,
      HfArgumentParser,
      TFAutoModelForTokenClassification,
      TFTrainer,
      TFTrainingArguments,
  )
  from transformers.utils import logging as hf_logging
  
  
  hf_logging.set_verbosity_info()
  hf_logging.enable_default_handler()
  hf_logging.enable_explicit_format()
  
  
  lowerCAmelCase_   =   logging.getLogger(__name__)
  
  @dataclass
  class 				A    :
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default="""NER"""       ,metadata={"""help""": """Task type to fine tune in training (e.g. NER, POS, etc)"""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}				)
        _SCREAMING_SNAKE_CASE					=							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.
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}       ,)
  
  
  @dataclass
  class 				A    :
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """The input data dir. Should contain the .txt files for a CoNLL-2003-formatted task."""}				)
        _SCREAMING_SNAKE_CASE					=							field(
            metadata={"""help""": """Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."""}				)
        _SCREAMING_SNAKE_CASE					=							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."""
                )
            }       ,)
        _SCREAMING_SNAKE_CASE					=							field(
            default=__UpperCAmelCase       ,metadata={"""help""": """Overwrite the cached training and evaluation sets"""}				)
  
  
  
  
  def 						A_			(  )			->						str:
         # 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      :							Any     				=						HfArgumentParser((ModelArguments, DataTrainingArguments, TFTrainingArguments)  )
         _snake_case				,    _snake_case				,    _snake_case      :							List[Any]     				=						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      :							Optional[Any]     				=						import_module('''tasks'''  )
  
         try:
                _snake_case      :							List[Any]     				=						getattr(lowercase_      ,		model_args.task_type  )
                _snake_case      :							TokenClassificationTask     				=						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      ,		)
         logger.info(
             '''n_replicas: %s, distributed training: %s, 16-bits training: %s'''      ,		training_args.n_replicas      ,		bool(training_args.n_replicas > 1  )      ,		training_args.fpaa      ,		)
         logger.info('''Training/evaluation parameters %s'''      ,		lowercase_  )
  
         # Prepare Token Classification task
         _snake_case      :							Optional[int]     				=						token_classification_task.get_labels(data_args.labels  )
         _snake_case      :							Dict[int, str]     				=						dict(enumerate(lowercase_  )  )
         _snake_case      :							Any     				=						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      :							Dict     				=						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      :							Optional[int]     				=						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      ,		)
  
         with training_args.strategy.scope():
                _snake_case      :							List[str]     				=						TFAutoModelForTokenClassification.from_pretrained(
                    model_args.model_name_or_path      ,		from_pt=bool('''.bin''' in model_args.model_name_or_path  )      ,		config=lowercase_      ,		cache_dir=model_args.cache_dir      ,		)
  
         # Get datasets
         _snake_case      :							Dict     				=						(
             TFTokenClassificationDataset(
                 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      :							List[Any]     				=						(
             TFTokenClassificationDataset(
                 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_      ,		lowercase_  ) -> Tuple[List[int], List[int]]:
                _snake_case      :							str     				=						np.argmax(lowercase_      ,		axis=2  )
                _snake_case				,    _snake_case      :							Optional[int]     				=						preds.shape
                _snake_case      :							Any     				=						[[] for _ in range(lowercase_  )]
                _snake_case      :							List[str]     				=						[[] for _ in range(lowercase_  )]
  
                for i in range(lowercase_  ):
                       for j in range(lowercase_  ):
                              if label_ids[i, j] != -100:
                                     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_  ) -> Dict:
                _snake_case				,    _snake_case      :							Tuple     				=						align_predictions(p.predictions      ,		p.label_ids  )
  
                return {
                    "precision": precision_score(lowercase_      ,		lowercase_  ),
                    "recall": recall_score(lowercase_      ,		lowercase_  ),
                    "f1": fa_score(lowercase_      ,		lowercase_  ),
                }
  
         # Initialize our Trainer
         _snake_case      :							Dict     				=						TFTrainer(
             model=lowercase_      ,		args=lowercase_      ,		train_dataset=train_dataset.get_dataset() if train_dataset else None      ,		eval_dataset=eval_dataset.get_dataset() if eval_dataset else None      ,		compute_metrics=lowercase_      ,		)
  
         # Training
         if training_args.do_train:
                trainer.train()
                trainer.save_model()
                tokenizer.save_pretrained(training_args.output_dir  )
  
         # Evaluation
         _snake_case      :							str     				=						{}
         if training_args.do_eval:
                logger.info('''*** Evaluate ***'''  )
  
                _snake_case      :							List[str]     				=						trainer.evaluate()
                _snake_case      :							Optional[Any]     				=						os.path.join(training_args.output_dir      ,		'''eval_results.txt'''  )
  
                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      :							Union[str, Any]     				=						TFTokenClassificationDataset(
                    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      :							Dict     				=						trainer.predict(test_dataset.get_dataset()  )
                _snake_case				,    _snake_case      :							List[Any]     				=						align_predictions(lowercase_      ,		lowercase_  )
                _snake_case      :							List[Any]     				=						classification_report(lowercase_      ,		lowercase_  )
  
                logger.info('''\n%s'''      ,		lowercase_  )
  
                _snake_case      :							Any     				=						os.path.join(training_args.output_dir      ,		'''test_results.txt'''  )
  
                with open(lowercase_      ,		'''w'''  ) as writer:
                       writer.write('''%s\n''' % report  )
  
                # Save predictions
                _snake_case      :							Union[str, Any]     				=						os.path.join(training_args.output_dir      ,		'''test_predictions.txt'''  )
  
                with open(lowercase_      ,		'''w'''  ) as writer:
                       with open(os.path.join(data_args.data_dir      ,		'''test.txt'''  )      ,		'''r'''  ) as f:
                              _snake_case      :							List[str]     				=						0
  
                              for line in f:
                                     if line.startswith('''-DOCSTART-'''  ) or line == "" or line == "\n":
                                            writer.write(lowercase_  )
  
                                            if not preds_list[example_id]:
                                                   example_id += 1
                                     elif preds_list[example_id]:
                                            _snake_case      :							Any     				=						line.split()[0] + ''' ''' + preds_list[example_id].pop(0  ) + '''\n'''
  
                                            writer.write(lowercase_  )
                                     else:
                                            logger.warning('''Maximum sequence length exceeded: No prediction for \'%s\'.'''      ,		line.split()[0]  )
  
         return results
  
  
  if __name__ == "__main__":
     main()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  from functools import partial
  from typing import Any, Callable, Dict, List, Type, TypeVar, Union, overload
  
  import torch
  import torch.nn as nn
  import torch.types
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						torch.Tensor:
         # The first operation in a checkpoint can't be in-place, but it's
         # nice to have in-place addition during inference. Thus...
         if not inplace:
                _snake_case      :							Any     				=						ma + ma
         else:
                ma += ma
  
         return ma
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						torch.Tensor:
         _snake_case      :							str     				=						-1 * len(lowercase_  )
         _snake_case      :							Any     				=						list(range(len(tensor.shape[:zero_index]  )  )  )
         return tensor.permute(first_inds + [zero_index + i for i in inds]  )
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						torch.Tensor:
         return t.reshape(t.shape[:-no_dims] + (-1,)  )
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_      ,		lowercase_ = 1E-4  )			->						torch.Tensor:
         _snake_case      :							Any     				=						mask.expand(*value.shape  )
         return torch.sum(mask * value      ,		dim=lowercase_  ) / (eps + torch.sum(lowercase_      ,		dim=lowercase_  ))
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_ = 2.31_25      ,		lowercase_ = 21.68_75      ,		lowercase_ = 64  )			->						torch.Tensor:
         _snake_case      :							int     				=						torch.linspace(lowercase_      ,		lowercase_      ,		no_bins - 1      ,		device=pts.device  )
         _snake_case      :							Optional[Any]     				=						torch.sqrt(torch.sum((pts.unsqueeze(-2  ) - pts.unsqueeze(-3  )) ** 2      ,		dim=-1  )  )
         return torch.bucketize(lowercase_      ,		lowercase_  )
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						dict:
         _snake_case      :							Dict     				=						dicts[0]
         _snake_case      :							str     				=						{}
         for k, v in first.items():
                _snake_case      :							List[Any]     				=						[d[k] for d in dicts]
                if isinstance(lowercase_      ,		lowercase_  ):
                       _snake_case      :							Any     				=						dict_multimap(lowercase_      ,		lowercase_  )
                else:
                       _snake_case      :							Dict     				=						fn(lowercase_  )
  
         return new_dict
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						torch.Tensor:
         _snake_case      :							str     				=						v_bins.view(((1,) * len(x.shape  )) + (len(lowercase_  ),)  )
         _snake_case      :							Union[str, Any]     				=						x[..., None] - reshaped_bins
         _snake_case      :							Optional[Any]     				=						torch.argmin(torch.abs(lowercase_  )      ,		dim=-1  )
         return nn.functional.one_hot(lowercase_      ,		num_classes=len(lowercase_  )  ).float()
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_ = 0      ,		lowercase_ = 0  )			->						torch.Tensor:
         _snake_case      :							List[Union[slice, torch.Tensor]]     				=						[]
         for i, s in enumerate(data.shape[:no_batch_dims]  ):
                _snake_case      :							Optional[Any]     				=						torch.arange(lowercase_  )
                _snake_case      :							Union[str, Any]     				=						r.view(*(*((1,) * i), -1, *((1,) * (len(inds.shape  ) - i - 1)))  )
                ranges.append(lowercase_  )
  
         _snake_case      :							List[Union[slice, torch.Tensor]]     				=						[slice(lowercase_  ) for _ in range(len(data.shape  ) - no_batch_dims  )]
         _snake_case      :							Union[str, Any]     				=						inds
         ranges.extend(lowercase_  )
         # Matt note: Editing this to get around the behaviour of using a list as an array index changing
         # in recent Numpy versions
         return data[tuple(lowercase_  )]
  
  
  lowerCAmelCase_   =   TypeVar("T")
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						Dict[Any, Union[dict, list, tuple, Any]]:
         _snake_case      :							Dict[Any, Union[dict, list, tuple, Any]]     				=						{}
         for k, v in dic.items():
                if isinstance(lowercase_      ,		lowercase_  ):
                       _snake_case      :							Dict     				=						dict_map(lowercase_      ,		lowercase_      ,		lowercase_  )
                else:
                       _snake_case      :							List[Any]     				=						tree_map(lowercase_      ,		lowercase_      ,		lowercase_  )
  
         return new_dict
  
  
  
  
  @overload
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						Any:
         ...
  
  
  
  
  @overload
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						dict:
         ...
  
  
  
  
  @overload
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						list:
         ...
  
  
  
  
  @overload
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						tuple:
         ...
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_      ,		lowercase_  )			->						Any:
         if isinstance(lowercase_      ,		lowercase_  ):
                return dict_map(lowercase_      ,		lowercase_      ,		lowercase_  )
         elif isinstance(lowercase_      ,		lowercase_  ):
                return [tree_map(lowercase_      ,		lowercase_      ,		lowercase_  ) for x in tree]
         elif isinstance(lowercase_      ,		lowercase_  ):
                return tuple(tree_map(lowercase_      ,		lowercase_      ,		lowercase_  ) for x in tree  )
         elif isinstance(lowercase_      ,		lowercase_  ):
                return fn(lowercase_  )
         else:
                print(type(lowercase_  )  )
                raise ValueError('''Not supported'''  )
  lowerCAmelCase_   =   partial(tree_map, leaf_type=torch.Tensor)
  
  
  
  
  
  
  