


"""simple docstring"""



import unittest

from transformers import JukeboxTokenizer
from transformers.testing_utils import require_torch







class _lowerCAmelCase				(      unittest.TestCase	):
   __UpperCAmelCase :       Union[str, Any]							  =  JukeboxTokenizer
   __UpperCAmelCase :       Union[str, Any]							  =  {
       '''artist''': '''Zac Brown Band''',
       '''genres''': '''Country''',
       '''lyrics''': '''I met a traveller from an antique land,
        Who said "Two vast and trunkless legs of stone
        Stand in the desert. . . . Near them, on the sand,
        Half sunk a shattered visage lies, whose frown,
        And wrinkled lip, and sneer of cold command,
        Tell that its sculptor well those passions read
        Which yet survive, stamped on these lifeless things,
        The hand that mocked them, and the heart that fed;
        And on the pedestal, these words appear:
        My name is Ozymandias, King of Kings;
        Look on my Works, ye Mighty, and despair!
        Nothing beside remains. Round the decay
        Of that colossal Wreck, boundless and bare
        The lone and level sands stretch far away
        ''',
   }







   @require_torch
   def  lowerCamelCase		(	self						)	->		int:

       '''simple docstring'''




       import torch

       snake_case    :      Any      					=    JukeboxTokenizer.from_pretrained("openai/jukebox-1b-lyrics"						)
       snake_case    :      Optional[Any]      					=    tokenizer(**self.metas						)["input_ids"]
       # fmt: off
       snake_case    :      Optional[int]      					=    [
           torch.tensor([[
               0, 0, 0, 7169, 507, 9, 76, 39, 31, 46, 76, 27,
               76, 46, 44, 27, 48, 31, 38, 38, 31, 44, 76, 32,
               44, 41, 39, 76, 27, 40, 76, 27, 40, 46, 35, 43,
               47, 31, 76, 38, 27, 40, 30, 64, 78, 76, 76, 76,
               76, 76, 76, 76, 76, 23, 34, 41, 76, 45, 27, 35,
               30, 76, 71, 20, 49, 41, 76, 48, 27, 45, 46, 76,
               27, 40, 30, 76, 46, 44, 47, 40, 37, 38, 31, 45,
               45, 76, 38, 31, 33, 45, 76, 41, 32, 76, 45, 46,
               41, 40, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               19, 46, 27, 40, 30, 76, 35, 40, 76, 46, 34, 31,
               76, 30, 31, 45, 31, 44, 46, 63, 76, 63, 76, 63,
               76, 63, 76, 14, 31, 27, 44, 76, 46, 34, 31, 39,
               64, 76, 41, 40, 76, 46, 34, 31, 76, 45, 27, 40,
               30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76, 8,
               27, 38, 32, 76, 45, 47, 40, 37, 76, 27, 76, 45,
               34, 27, 46, 46, 31, 44, 31, 30, 76, 48, 35, 45,
               27, 33, 31, 76, 38, 35, 31, 45, 64, 76, 49, 34,
               41, 45, 31, 76, 32, 44, 41, 49, 40, 64, 78, 76,
               76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76, 49,
               44, 35, 40, 37, 38, 31, 30, 76, 38, 35, 42, 64,
               76, 27, 40, 30, 76, 45, 40, 31, 31, 44, 76, 41,
               32, 76, 29, 41, 38, 30, 76, 29, 41, 39, 39, 27,
               40, 30, 64, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               20, 31, 38, 38, 76, 46, 34, 27, 46, 76, 35, 46,
               45, 76, 45, 29, 47, 38, 42, 46, 41, 44, 76, 49,
               31, 38, 38, 76, 46, 34, 41, 45, 31, 76, 42, 27,
               45, 45, 35, 41, 40, 45, 76, 44, 31, 27, 30, 78,
               76, 76, 76, 76, 76, 76, 76, 76, 23, 34, 35, 29,
               34, 76, 51, 31, 46, 76, 45, 47, 44, 48, 35, 48,
               31, 64, 76, 45, 46, 27, 39, 42, 31, 30, 76, 41,
               40, 76, 46, 34, 31, 45, 31, 76, 38, 35, 32, 31,
               38, 31, 45, 45, 76, 46, 34, 35, 40, 33, 45, 64,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 20, 34, 31,
               76, 34, 27, 40, 30, 76, 46, 34, 27, 46, 76, 39,
               41, 29, 37, 31, 30, 76, 46, 34, 31, 39, 64, 76,
               27, 40, 30, 76, 46, 34, 31, 76, 34, 31, 27, 44,
               46, 76, 46, 34, 27, 46, 76, 32, 31, 30, 66, 78,
               76, 76, 76, 76, 76, 76, 76, 76, 1, 40, 30, 76,
               41, 40, 76, 46, 34, 31, 76, 42, 31, 30, 31, 45,
               46, 27, 38, 64, 76, 46, 34, 31, 45, 31, 76, 49,
               41, 44, 30, 45, 76, 27, 42, 42, 31, 27, 44, 65,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 13, 51, 76,
               40, 27, 39, 31, 76, 35, 45, 76, 15, 52, 51, 39,
               27, 40, 30, 35, 27, 45, 64, 76, 11, 35, 40, 33,
               76, 41, 32, 76, 11, 35, 40, 33, 45, 66, 78, 76,
               76, 76, 76, 76, 76, 76, 76, 12, 41, 41, 37, 76,
               41, 40, 76, 39, 51, 76, 23, 41, 44, 37, 45, 64,
               76, 51, 31, 76, 13, 35, 33, 34, 46, 51, 64, 76,
               27, 40, 30, 76, 30, 31, 45, 42, 27, 35, 44, 67,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 14, 41, 46,
               34, 35, 40, 33, 76, 28, 31, 45, 35, 30, 31, 76,
               44, 31, 39, 27, 35, 40, 45, 63, 76, 18, 41, 47,
               40, 30, 76, 46, 34, 31, 76, 30, 31, 29, 27, 51,
               78, 76, 76, 76, 76, 76, 76, 76, 76, 15, 32, 76,
               46, 34, 27, 46, 76, 29, 41, 38, 41, 45, 45, 27,
               38, 76, 23, 44, 31, 29, 37, 64, 76, 28, 41, 47,
               40, 30, 38, 31, 45, 45, 76, 27, 40, 30, 76, 28,
               27, 44, 31, 78, 76, 76, 76, 76, 76, 76, 76, 76,
               20, 34, 31, 76, 38, 41, 40, 31, 76, 27, 40, 30,
               76, 38, 31, 48, 31, 38, 76, 45, 27, 40, 30, 45,
               76, 45, 46, 44, 31, 46, 29, 34, 76, 32, 27, 44,
               76, 27, 49, 27, 51, 78, 76, 76, 76, 76, 76, 76,
               76, 76]]						),
           torch.tensor([[0, 0, 0, 1069, 11]]						),
           torch.tensor([[0, 0, 0, 1069, 11]]						),
       ]
       # fmt: on
       self.assertTrue(torch.allclose(tokens[0]						,	EXPECTED_OUTPUT[0]						)						)
       self.assertTrue(torch.allclose(tokens[1]						,	EXPECTED_OUTPUT[1]						)						)
       self.assertTrue(torch.allclose(tokens[2]						,	EXPECTED_OUTPUT[2]						)						)







   @require_torch
   def  lowerCamelCase		(	self						)	->		Any:

       '''simple docstring'''




       import torch

       snake_case    :      Tuple      					=    JukeboxTokenizer.from_pretrained("openai/jukebox-5b-lyrics"						)
       snake_case    :      Optional[Any]      					=    tokenizer(**self.metas						)["input_ids"]
       # fmt: off
       snake_case    :      List[Any]      					=    [
           torch.tensor([[
               0, 0, 0, 1069, 11, -1, -1, -1, -1, 9, 77, 39,
               31, 46, 77, 27, 77, 46, 44, 27, 48, 31, 38, 38,
               31, 44, 77, 32, 44, 41, 39, 77, 27, 40, 77, 27,
               40, 46, 35, 43, 47, 31, 77, 38, 27, 40, 30, 64,
               79, 77, 77, 77, 77, 77, 77, 77, 77, 23, 34, 41,
               77, 45, 27, 35, 30, 77, 72, 20, 49, 41, 77, 48,
               27, 45, 46, 77, 27, 40, 30, 77, 46, 44, 47, 40,
               37, 38, 31, 45, 45, 77, 38, 31, 33, 45, 77, 41,
               32, 77, 45, 46, 41, 40, 31, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 19, 46, 27, 40, 30, 77, 35, 40,
               77, 46, 34, 31, 77, 30, 31, 45, 31, 44, 46, 63,
               77, 63, 77, 63, 77, 63, 77, 14, 31, 27, 44, 77,
               46, 34, 31, 39, 64, 77, 41, 40, 77, 46, 34, 31,
               77, 45, 27, 40, 30, 64, 79, 77, 77, 77, 77, 77,
               77, 77, 77, 8, 27, 38, 32, 77, 45, 47, 40, 37,
               77, 27, 77, 45, 34, 27, 46, 46, 31, 44, 31, 30,
               77, 48, 35, 45, 27, 33, 31, 77, 38, 35, 31, 45,
               64, 77, 49, 34, 41, 45, 31, 77, 32, 44, 41, 49,
               40, 64, 79, 77, 77, 77, 77, 77, 77, 77, 77, 1,
               40, 30, 77, 49, 44, 35, 40, 37, 38, 31, 30, 77,
               38, 35, 42, 64, 77, 27, 40, 30, 77, 45, 40, 31,
               31, 44, 77, 41, 32, 77, 29, 41, 38, 30, 77, 29,
               41, 39, 39, 27, 40, 30, 64, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 20, 31, 38, 38, 77, 46, 34, 27,
               46, 77, 35, 46, 45, 77, 45, 29, 47, 38, 42, 46,
               41, 44, 77, 49, 31, 38, 38, 77, 46, 34, 41, 45,
               31, 77, 42, 27, 45, 45, 35, 41, 40, 45, 77, 44,
               31, 27, 30, 79, 77, 77, 77, 77, 77, 77, 77, 77,
               23, 34, 35, 29, 34, 77, 51, 31, 46, 77, 45, 47,
               44, 48, 35, 48, 31, 64, 77, 45, 46, 27, 39, 42,
               31, 30, 77, 41, 40, 77, 46, 34, 31, 45, 31, 77,
               38, 35, 32, 31, 38, 31, 45, 45, 77, 46, 34, 35,
               40, 33, 45, 64, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 20, 34, 31, 77, 34, 27, 40, 30, 77, 46, 34,
               27, 46, 77, 39, 41, 29, 37, 31, 30, 77, 46, 34,
               31, 39, 64, 77, 27, 40, 30, 77, 46, 34, 31, 77,
               34, 31, 27, 44, 46, 77, 46, 34, 27, 46, 77, 32,
               31, 30, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77,
               1, 40, 30, 77, 41, 40, 77, 46, 34, 31, 77, 42,
               31, 30, 31, 45, 46, 27, 38, 64, 77, 46, 34, 31,
               45, 31, 77, 49, 41, 44, 30, 45, 77, 27, 42, 42,
               31, 27, 44, 65, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 13, 51, 77, 40, 27, 39, 31, 77, 35, 45, 77,
               15, 52, 51, 39, 27, 40, 30, 35, 27, 45, 64, 77,
               11, 35, 40, 33, 77, 41, 32, 77, 11, 35, 40, 33,
               45, 66, 79, 77, 77, 77, 77, 77, 77, 77, 77, 12,
               41, 41, 37, 77, 41, 40, 77, 39, 51, 77, 23, 41,
               44, 37, 45, 64, 77, 51, 31, 77, 13, 35, 33, 34,
               46, 51, 64, 77, 27, 40, 30, 77, 30, 31, 45, 42,
               27, 35, 44, 67, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 14, 41, 46, 34, 35, 40, 33, 77, 28, 31, 45,
               35, 30, 31, 77, 44, 31, 39, 27, 35, 40, 45, 63,
               77, 18, 41, 47, 40, 30, 77, 46, 34, 31, 77, 30,
               31, 29, 27, 51, 79, 77, 77, 77, 77, 77, 77, 77,
               77, 15, 32, 77, 46, 34, 27, 46, 77, 29, 41, 38,
               41, 45, 45, 27, 38, 77, 23, 44, 31, 29, 37, 64,
               77, 28, 41, 47, 40, 30, 38, 31, 45, 45, 77, 27,
               40, 30, 77, 28, 27, 44, 31, 79, 77, 77, 77, 77,
               77, 77, 77, 77, 20, 34, 31, 77, 38, 41, 40, 31,
               77, 27, 40, 30, 77, 38, 31, 48, 31, 38, 77, 45,
               27, 40, 30, 45, 77, 45, 46, 44, 31, 46, 29, 34,
               77, 32, 27, 44, 77, 27, 49, 27, 51, 79, 77, 77,
               77, 77, 77, 77, 77, 77]]						),
           torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]						),
           torch.tensor([[0, 0, 0, 1069, 11, -1, -1, -1, -1]]						),
       ]
       # fmt: on
       self.assertTrue(torch.allclose(tokens[0]						,	EXPECTED_OUTPUT[0]						)						)
       self.assertTrue(torch.allclose(tokens[1]						,	EXPECTED_OUTPUT[1]						)						)
       self.assertTrue(torch.allclose(tokens[2]						,	EXPECTED_OUTPUT[2]						)						)









"""simple docstring"""



import argparse
import glob
import logging
import os
from argparse import Namespace
from importlib import import_module

import numpy as np
import torch
from lightning_base import BaseTransformer, add_generic_args, generic_train
from seqeval.metrics import accuracy_score, fa_score, precision_score, recall_score
from torch.nn import CrossEntropyLoss
from torch.utils.data import DataLoader, TensorDataset
from utils_ner import TokenClassificationTask


__snake_case   			=    logging.getLogger(__name__)







class _lowerCAmelCase				(      snake_case_	):
   __UpperCAmelCase :       Optional[int]							  =  '''token-classification'''







   def __init__(	self						,	UpperCamelCase__						)	->		List[Any]:

       '''simple docstring'''




       if type(UpperCamelCase__						) == dict:
           snake_case    :      Optional[int]      					=    Namespace(**UpperCamelCase__						)
       snake_case    :      Optional[int]      					=    import_module("tasks"						)
       try:
           snake_case    :      Optional[int]      					=    getattr(UpperCamelCase__						,	hparams.task_type						)
           snake_case    :      TokenClassificationTask      					=    token_classification_task_clazz()
       except AttributeError:
           raise ValueError(
               F'Task {hparams.task_type} needs to be defined as a TokenClassificationTask subclass in {module}. '
               F'Available tasks classes are: {TokenClassificationTask.__subclasses__()}'						)
       snake_case    :      str      					=    self.token_classification_task.get_labels(hparams.labels						)
       snake_case    :      Union[str, Any]      					=    CrossEntropyLoss().ignore_index
       super().__init__(UpperCamelCase__						,	len(self.labels						)						,	self.mode						)







   def  lowerCamelCase		(	self						,	**UpperCamelCase__						)	->		Any:

       '''simple docstring'''




       return self.model(**UpperCamelCase__						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__						)	->		Tuple:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
       if self.config.model_type != "distilbert":
           snake_case    :      Optional[int]      					=    (
               batch[2] if self.config.model_type in ["bert", "xlnet"] else None
           )  # XLM and RoBERTa don"t use token_type_ids

       snake_case    :      List[Any]      					=    self(**UpperCamelCase__						)
       snake_case    :      Union[str, Any]      					=    outputs[0]
       # tensorboard_logs = {"loss": loss, "rate": self.lr_scheduler.get_last_lr()[-1]}
       return {"loss": loss}







   def  lowerCamelCase		(	self						)	->		Optional[int]:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    self.hparams
       for mode in ["train", "dev", "test"]:
           snake_case    :      Optional[Any]      					=    self._feature_file(UpperCamelCase__						)
           if os.path.exists(UpperCamelCase__						) and not args.overwrite_cache:
               logger.info("Loading features from cached file %s"						,	UpperCamelCase__						)
               snake_case    :      List[str]      					=    torch.load(UpperCamelCase__						)
           else:
               logger.info("Creating features from dataset file at %s"						,	args.data_dir						)
               snake_case    :      Optional[Any]      					=    self.token_classification_task.read_examples_from_file(args.data_dir						,	UpperCamelCase__						)
               snake_case    :      Dict      					=    self.token_classification_task.convert_examples_to_features(
                   UpperCamelCase__						,	self.labels						,	args.max_seq_length						,	self.tokenizer						,	cls_token_at_end=bool(self.config.model_type in ["xlnet"]						)						,	cls_token=self.tokenizer.cls_token						,	cls_token_segment_id=2 if self.config.model_type in ["xlnet"] else 0						,	sep_token=self.tokenizer.sep_token						,	sep_token_extra=UpperCamelCase__						,	pad_on_left=bool(self.config.model_type in ["xlnet"]						)						,	pad_token=self.tokenizer.pad_token_id						,	pad_token_segment_id=self.tokenizer.pad_token_type_id						,	pad_token_label_id=self.pad_token_label_id						,	)
               logger.info("Saving features into cached file %s"						,	UpperCamelCase__						)
               torch.save(UpperCamelCase__						,	UpperCamelCase__						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__ = False						)	->		DataLoader:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    self._feature_file(UpperCamelCase__						)
       logger.info("Loading features from cached file %s"						,	UpperCamelCase__						)
       snake_case    :      Any      					=    torch.load(UpperCamelCase__						)
       snake_case    :      Tuple      					=    torch.tensor([f.input_ids for f in features]						,	dtype=torch.long						)
       snake_case    :      List[str]      					=    torch.tensor([f.attention_mask for f in features]						,	dtype=torch.long						)
       if features[0].token_type_ids is not None:
           snake_case    :      Tuple      					=    torch.tensor([f.token_type_ids for f in features]						,	dtype=torch.long						)
       else:
           snake_case    :      Union[str, Any]      					=    torch.tensor([0 for f in features]						,	dtype=torch.long						)
           # HACK(we will not use this anymore soon)
       snake_case    :      Optional[int]      					=    torch.tensor([f.label_ids for f in features]						,	dtype=torch.long						)
       return DataLoader(
           TensorDataset(UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__						,	UpperCamelCase__						)						,	batch_size=UpperCamelCase__						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__						)	->		Optional[Any]:

       '''simple docstring'''




       """Compute validation""" ""
       snake_case    :      Any      					=    {"input_ids": batch[0], "attention_mask": batch[1], "labels": batch[3]}
       if self.config.model_type != "distilbert":
           snake_case    :      Optional[int]      					=    (
               batch[2] if self.config.model_type in ["bert", "xlnet"] else None
           )  # XLM and RoBERTa don"t use token_type_ids
       snake_case    :      Optional[int]      					=    self(**UpperCamelCase__						)
       snake_case					,snake_case    :      str      					=    outputs[:2]
       snake_case    :      Optional[int]      					=    logits.detach().cpu().numpy()
       snake_case    :      str      					=    inputs["labels"].detach().cpu().numpy()
       return {"val_loss": tmp_eval_loss.detach().cpu(), "pred": preds, "target": out_label_ids}







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Any:

       '''simple docstring'''




       snake_case    :      Dict      					=    torch.stack([x["val_loss"] for x in outputs]						).mean()
       snake_case    :      List[str]      					=    np.concatenate([x["pred"] for x in outputs]						,	axis=0						)
       snake_case    :      Any      					=    np.argmax(UpperCamelCase__						,	axis=2						)
       snake_case    :      Dict      					=    np.concatenate([x["target"] for x in outputs]						,	axis=0						)

       snake_case    :      Tuple      					=    dict(enumerate(self.labels						)						)
       snake_case    :      str      					=    [[] for _ in range(out_label_ids.shape[0]						)]
       snake_case    :      List[Any]      					=    [[] for _ in range(out_label_ids.shape[0]						)]

       for i in range(out_label_ids.shape[0]						):
           for j in range(out_label_ids.shape[1]						):
               if out_label_ids[i, j] != self.pad_token_label_id:
                   out_label_list[i].append(label_map[out_label_ids[i][j]]						)
                   preds_list[i].append(label_map[preds[i][j]]						)

       snake_case    :      Union[str, Any]      					=    {
           "val_loss": val_loss_mean,
           "accuracy_score": accuracy_score(UpperCamelCase__						,	UpperCamelCase__						),
           "precision": precision_score(UpperCamelCase__						,	UpperCamelCase__						),
           "recall": recall_score(UpperCamelCase__						,	UpperCamelCase__						),
           "f1": fa_score(UpperCamelCase__						,	UpperCamelCase__						),
       }

       snake_case    :      int      					=    dict(results.items()						)
       snake_case    :      Union[str, Any]      					=    results
       return ret, preds_list, out_label_list







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		List[str]:

       '''simple docstring'''




       snake_case					,snake_case					,snake_case    :      Optional[Any]      					=    self._eval_end(UpperCamelCase__						)
       snake_case    :      Tuple      					=    ret["log"]
       return {"val_loss": logs["val_loss"], "log": logs, "progress_bar": logs}







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		Any:

       '''simple docstring'''




       snake_case					,snake_case					,snake_case    :      List[Any]      					=    self._eval_end(UpperCamelCase__						)

       # Converting to the dict required by pl
       # https://github.com/PyTorchLightning/pytorch-lightning/blob/master/\
       # pytorch_lightning/trainer/logging.py#L139
       snake_case    :      Optional[Any]      					=    ret["log"]
       # `val_loss` is the key returned by `self._eval_end()` but actually refers to `test_loss`
       return {"avg_test_loss": logs["val_loss"], "log": logs, "progress_bar": logs}







   @staticmethod
   def  lowerCamelCase		(	UpperCamelCase__						,	UpperCamelCase__						)	->		str:

       '''simple docstring'''




       BaseTransformer.add_model_specific_args(UpperCamelCase__						,	UpperCamelCase__						)
       parser.add_argument(
           "--task_type"						,	default="NER"						,	type=UpperCamelCase__						,	help="Task type to fine tune in training (e.g. NER, POS, etc)"						)
       parser.add_argument(
           "--max_seq_length"						,	default=128						,	type=UpperCamelCase__						,	help=(
               "The maximum total input sequence length after tokenization. Sequences longer "
               "than this will be truncated, sequences shorter will be padded."
           )						,	)

       parser.add_argument(
           "--labels"						,	default=""						,	type=UpperCamelCase__						,	help="Path to a file containing all labels. If not specified, CoNLL-2003 labels are used."						,	)
       parser.add_argument(
           "--gpus"						,	default=0						,	type=UpperCamelCase__						,	help="The number of GPUs allocated for this, it is by default 0 meaning none"						,	)

       parser.add_argument(
           "--overwrite_cache"						,	action="store_true"						,	help="Overwrite the cached training and evaluation sets"						)

       return parser


if __name__ == "__main__":
  __snake_case   			=    argparse.ArgumentParser()
  add_generic_args(parser, os.getcwd())
  __snake_case   			=    NERTransformer.add_model_specific_args(parser, os.getcwd())
  __snake_case   			=    parser.parse_args()
  __snake_case   			=    NERTransformer(args)
  __snake_case   			=    generic_train(model, args)

  if args.do_predict:
    # See https://github.com/huggingface/transformers/issues/3159
    # pl use this default format to create a checkpoint:
    # https://github.com/PyTorchLightning/pytorch-lightning/blob/master\
    # /pytorch_lightning/callbacks/model_checkpoint.py#L322
    __snake_case   			=    sorted(glob.glob(os.path.join(args.output_dir, """checkpoint-epoch=*.ckpt"""), recursive=True))
    __snake_case   			=    model.load_from_checkpoint(checkpoints[-1])
    trainer.test(model)





