Página Inicial>Relacionado com a programação>Outro código-fonte
Baixar

T-ner: uma biblioteca Python geral para reconhecimento de entidade nomeado baseado em transformadores

O T -ner é uma ferramenta Python para o Modelo de Idioma Finetuning no NER-INDITY-RECONCONCIONAL (NER) implementado em Pytorch, disponível via PIP. Possui uma interface fácil para os modelos FineTune e testar nos conjuntos de dados cruzados e multilíngues. Atualmente, o T -ner integra alta cobertura de conjuntos de dados NER publicamente disponíveis e permite uma fácil integração de conjuntos de dados personalizados. Todos os modelos FinetUned com T -ner podem ser implantados em nosso aplicativo da web para visualização. Nosso artigo demonstrando que o T-AR foi aceito no EACL 2021. Todos os modelos e conjuntos de dados são compartilhados via grupo de huggingface t-ner.

NOVO (setembro de 2022): Lançamos o novo conjunto de dados NER baseado no Twitter tweetner7 e o artigo foi aceito pela AACL 2022 Principal Conference! Lançamos o conjunto de dados, juntamente com modelos de ajuste fino, e mais detalhes podem ser encontrados na página de documentos, repositório e conjunto de dados. O modelo NER do Twitter também foi integrado ao tweetnlp e uma demonstração está disponível aqui.

  • Recursos: Model_Card , DataSet_Card , Gradio Online Demo
  • Huggingface: https://huggingface.co/tner
  • Github: https://github.com/asahi417/tner
  • Papéis
    • T-PER (EACL2021): ACL Anthology , Arxiv
    • Tweetner7 (AACL 2022): Arxiv

Instale tner via Pip para começar! 

pip install tner

Índice

  1. Conjunto de dados
    1.1 conjunto de dados predefinido
    1.2 conjunto de dados personalizado
  2. Modelo
  3. Modelo de linguagem de ajuste fino no nerd
  4. Avaliando o modelo NER
  5. API da web
  6. Exemplos de colab
  7. Referência

Exemplos do Google Colab

Descrição Link
Modelo Finetuning & Avaliação
Previsão de modelos
Fluxo de trabalho NER multilíngue

Conjunto de dados

Um conjunto de dados NER contém uma sequência de tokens e tags para cada divisão (geralmente train / validation / test ), 

{
    'train' : {
        'tokens' : [
            [ '@paulwalk' , 'It' , "'s" , 'the' , 'view' , 'from' , 'where' , 'I' , "'m" , 'living' , 'for' , 'two' , 'weeks' , '.' , 'Empire' , 'State' , 'Building' , '=' , 'ESB' , '.' , 'Pretty' , 'bad' , 'storm' , 'here' , 'last' , 'evening' , '.' ],
            [ 'From' , 'Green' , 'Newsfeed' , ':' , 'AHFA' , 'extends' , 'deadline' , 'for' , 'Sage' , 'Award' , 'to' , 'Nov' , '.' , '5' , 'http://tinyurl.com/24agj38' ], ...
        ],
        'tags' : [
            [ 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 1 , 2 , 2 , 0 , 1 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ],
            [ 0 , 0 , 0 , 0 , 3 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 ], ...
        ]
    },
    'validation' : ...,
    'test' : ...,
}

com um dicionário para mapear um rótulo para o seu índice ( label2id ) como abaixo. 

{ "O" : 0 , "B-ORG" : 1 , "B-MISC" : 2 , "B-PER" : 3 , "I-PER" : 4 , "B-LOC" : 5 , "I-ORG" : 6 , "I-MISC" : 7 , "I-LOC" : 8 }

DataSet predefinido

Uma variedade de conjuntos de dados públicos de NER está disponível em nosso grupo Huggingface, que pode ser usado como abaixo (consulte o cartão do conjunto de dados para obter listas de dados completas). 

 from tner import get_dataset
data , label2id = get_dataset ( dataset = "tner/wnut2017" )

O usuário pode especificar vários conjuntos de dados para obter um conjunto de dados concatenado. 

 data , label2id = get_dataset ( dataset = [ "tner/conll2003" , "tner/ontonotes5" ])

Nos conjuntos de dados concatenados, usamos o rótulo unificado definido para unificar o rótulo da entidade. A idéia é compartilhar todos os conjuntos de dados NER disponíveis no Huggingface em um formato unificado, então informe -nos se você deseja que algum conjunto de dados NER seja adicionado lá!

Conjunto de dados personalizado

Para ir além dos conjuntos de dados públicos, os usuários podem usar seus próprios conjuntos de dados, formatando -os no formato IOB descrito no documento de tarefas compartilhado da CONLL 2003, onde todos os arquivos de dados contêm uma palavra por linha com linhas vazias representando limites da sentença. No final de cada linha, há uma tag que afirma se a palavra atual está dentro de uma entidade nomeada ou não. A tag também codifica o tipo de entidade nomeada. Aqui está uma frase de exemplo: 

 EU B-ORG
rejects O
German B-MISC
call O
to O
boycott O
British B-MISC
lamb O
. O

As palavras marcadas com O estão fora das entidades nomeadas e a tag i-xxx é usada para palavras dentro de uma entidade nomeada do tipo XXX. Sempre que duas entidades do tipo XXX estão imediatamente próximas uma da outra, a primeira palavra da segunda entidade será marcada B-XXX para mostrar que inicia outra entidade. Por favor, dê uma olhada na amostra de dados personalizados. Esses arquivos personalizados podem ser carregados da mesma maneira que o conjunto de dados HuggingFace, como abaixo. 

 from tner import get_dataset
data , label2id = get_dataset ( local_dataset = {
    "train" : "examples/local_dataset_sample/train.txt" ,
    "valid" : "examples/local_dataset_sample/train.txt" ,
    "test" : "examples/local_dataset_sample/test.txt"
})

O mesmo que o conjunto de dados HuggingFace, pode -se concatenar o conjunto de dados. 

 data , label2id = get_dataset ( local_dataset = [
   { "train" : "..." , "valid" : "..." , "test" : "..." },
   { "train" : "..." , "valid" : "..." , "test" : "..." }
   ]
)

Modelo

Atualmente, o T -ner compartilhou mais de 100 modelos NER no grupo HuggingFace, conforme mostrado na tabela acima, que relata apenas os principais modelos e veja Model_Card para listas de modelos completas. Todos os modelos podem ser usados ​​com tner como abaixo. 

 from tner import TransformersNER
model = TransformersNER ( "tner/roberta-large-wnut2017" )  # provide model alias on huggingface
output = model . predict ([ "Jacob Collier is a Grammy awarded English artist from London" ])  # give a list of sentences (or tokenized sentence) 
print ( output )
{
   'prediction' : [[ 'B-person' , 'I-person' , 'O' , 'O' , 'O' , 'O' , 'O' , 'O' , 'O' , 'B-location' ]],
   'probability' : [[ 0.9967652559280396 , 0.9994561076164246 , 0.9986955523490906 , 0.9947081804275513 , 0.6129112243652344 , 0.9984312653541565 , 0.9868122935295105 , 0.9983410835266113 , 0.9995284080505371 , 0.9838910698890686 ]],
   'input' : [[ 'Jacob' , 'Collier' , 'is' , 'a' , 'Grammy' , 'awarded' , 'English' , 'artist' , 'from' , 'London' ]],
   'entity_prediction' : [[
       { 'type' : 'person' , 'entity' : [ 'Jacob' , 'Collier' ], 'position' : [ 0 , 1 ], 'probability' : [ 0.9967652559280396 , 0.9994561076164246 ]},
       { 'type' : 'location' , 'entity' : [ 'London' ], 'position' : [ 9 ], 'probability' : [ 0.9838910698890686 ]}
    ]]
}

O model.predict pega uma lista de frases e tamanho em lote batch_size , opcionalmente, e tokeniza a frase por meio espaço ou o símbolo especificado pelo separator , que é retornado como input em seu objeto de saída. Opcionalmente, o usuário pode tokenizar as entradas com antecedência com qualquer tokenizer (spacy, nltk, etc) e a previsão seguirá a tokenização. 

 output = model . predict ([[ "Jacob Collier" , "is" , "a" , "Grammy awarded" , "English artist" , "from" , "London" ]])
print ( output )
{
    'prediction' : [[ 'B-person' , 'O' , 'O' , 'O' , 'O' , 'O' , 'B-location' ]],
    'probability' : [[ 0.9967652559280396 , 0.9986955523490906 , 0.9947081804275513 , 0.6129112243652344 , 0.9868122935295105 , 0.9995284080505371 , 0.9838910698890686 ]],
    'input' : [[ 'Jacob Collier' , 'is' , 'a' , 'Grammy awarded' , 'English artist' , 'from' , 'London' ]],
    'entity_prediction' : [[
        { 'type' : 'person' , 'entity' : [ 'Jacob Collier' ], 'position' : [ 0 ], 'probability' : [ 0.9967652559280396 ]},
        { 'type' : 'location' , 'entity' : [ 'London' ], 'position' : [ 6 ], 'probability' : [ 0.9838910698890686 ]}
    ]]
}

Um ponto de verificação do modelo local pode ser especificado em vez do modelo Alias TransformersNER("path-to-checkpoint") . O script para reproduzir esses modelos lançados está aqui.

ferramenta de linha de comando

A ferramenta de linha de comando a seguir está disponível para previsão do modelo. 

tner-predict [-h] -m MODEL

command line tool to test finetuned NER model

optional arguments:
  -h, --help            show this help message and exit
  -m MODEL, --model MODEL
                        model alias of huggingface or local checkpoint
  • Exemplo 
tner-predict -m " tner/roberta-large-wnut2017 "

Aplicativo da web

Para instalar dependências para executar o aplicativo da web, adicione a opção na instalação. 

pip install tner[app]

Então, clone o repositório 

git clone https://github.com/asahi417/tner
cd tner

e inicie o servidor. 

uvicorn app:app --reload --log-level debug --host 0.0.0.0 --port 8000

Abra seu navegador http://0.0.0.0:8000 Uma vez pronto. Você pode especificar o modelo a ser implantado por uma variável de ambiente NER_MODEL , que é definida como tner/roberta-large-wnut2017 como padrão. NER_MODEL pode ser um caminho para o diretório de ponto de verificação do modelo local ou o nome do modelo no Hub do modelo Transformers.

Reconhecimento A interface do aplicativo é fortemente inspirada neste repositório.

Modelo de linguagem de ajuste fino no nerd

O T -ner fornece uma API fácil para executar o modelo de linguagem fino no NER com uma pesquisa de parâmetros eficientes, conforme descrito acima. Consiste em 2 estágios: (i) ajuste fino com todas as configurações possíveis para uma pequena época e a métrica de avaliação de computação (Micro F1 como padrão) no conjunto de validação para todos os modelos e (ii) pega os modelos Top K para continuar a época de ajuste fino até L O melhor modelo no segundo estágio continuará ajustando fino até que a métrica de validação diminua.

Esse ajuste fino com pesquisa de parâmetros de dois estágios pode ser alcançado em algumas linhas com tner . 

 from tner import GridSearcher
searcher = GridSearcher (
   checkpoint_dir = './ckpt_tner' ,
   dataset = "tner/wnut2017" ,  # either of `dataset` (huggingface dataset) or `local_dataset` (custom dataset) should be given
   model = "roberta-large" ,  # language model to fine-tune
   epoch = 10 ,  # the total epoch (`L` in the figure)
   epoch_partial = 5 ,  # the number of epoch at 1st stage (`M` in the figure)
   n_max_config = 3 ,  # the number of models to pass to 2nd stage (`K` in the figure)
   batch_size = 16 ,
   gradient_accumulation_steps = [ 4 , 8 ],
   crf = [ True , False ],
   lr = [ 1e-4 , 1e-5 ],
   weight_decay = [ 1e-7 ],
   random_seed = [ 42 ],
   lr_warmup_step_ratio = [ 0.1 ],
   max_grad_norm = [ 10 ]  
)
searcher . train ()

Os seguintes parâmetros são ajustáveis ​​no momento.

  • gradient_accumulation_steps : o número de acumulação de gradiente
  • crf : Use CRF em cima da incorporação de saída
  • lr : Taxa de aprendizado
  • weight_decay : coeficiente para decaimento de peso
  • random_seed : semente aleatória
  • lr_warmup_step_ratio : taxa de aquecimento linear da taxa de aprendizagem, por exemplo) se for 0,3, a taxa de aprendizado se aquece linearmente até 30% da etapa total (afinal de decaimento)
  • max_grad_norm : norma para recorte de gradiente

Consulte a fonte para obter mais informações sobre cada argumento.

ferramenta de linha de comando

A ferramenta de linha de comando a seguir está disponível para ajuste fino. 

tner-train-search [-h] -c CHECKPOINT_DIR [-d DATASET [DATASET ...]] [-l LOCAL_DATASET [LOCAL_DATASET ...]]
                         [--dataset-name DATASET_NAME [DATASET_NAME ...]] [-m MODEL] [-b BATCH_SIZE] [-e EPOCH] [--max-length MAX_LENGTH] [--use-auth-token]
                         [--dataset-split-train DATASET_SPLIT_TRAIN] [--dataset-split-valid DATASET_SPLIT_VALID] [--lr LR [LR ...]]
                         [--random-seed RANDOM_SEED [RANDOM_SEED ...]] [-g GRADIENT_ACCUMULATION_STEPS [GRADIENT_ACCUMULATION_STEPS ...]]
                         [--weight-decay WEIGHT_DECAY [WEIGHT_DECAY ...]] [--lr-warmup-step-ratio LR_WARMUP_STEP_RATIO [LR_WARMUP_STEP_RATIO ...]]
                         [--max-grad-norm MAX_GRAD_NORM [MAX_GRAD_NORM ...]] [--crf CRF [CRF ...]] [--optimizer-on-cpu] [--n-max-config N_MAX_CONFIG]
                         [--epoch-partial EPOCH_PARTIAL] [--max-length-eval MAX_LENGTH_EVAL]

Fine-tune transformers on NER dataset with Robust Parameter Search

optional arguments:
  -h , --help            show this help message and exit
  -c CHECKPOINT_DIR, --checkpoint-dir CHECKPOINT_DIR
                        checkpoint directory
  -d DATASET [DATASET ...], --dataset DATASET [DATASET ...]
                        dataset name (or a list of it) on huggingface tner organization eg. ' tner/conll2003 ' [ ' tner/conll2003 ' , ' tner/ontonotes5 ' ]] see
                        https://huggingface.co/datasets ? search = tner for full dataset list
  -l LOCAL_DATASET [LOCAL_DATASET ...], --local-dataset LOCAL_DATASET [LOCAL_DATASET ...]
                        a dictionary (or a list) of paths to local BIO files eg.{ " train " : " examples/local_dataset_sample/train.txt " , " test " :
                        " examples/local_dataset_sample/test.txt " }
  --dataset-name DATASET_NAME [DATASET_NAME ...]
                        [optional] data name of huggingface dataset (should be same length as the ` dataset ` )
  -m MODEL, --model MODEL
                        model name of underlying language model (huggingface model)
  -b BATCH_SIZE, --batch-size BATCH_SIZE
                        batch size
  -e EPOCH, --epoch EPOCH
                        the number of epoch
  --max-length MAX_LENGTH
                        max length of language model
  --use-auth-token      Huggingface transformers argument of ` use_auth_token `
  --dataset-split-train DATASET_SPLIT_TRAIN
                        dataset split to be used for training ( ' train ' as default)
  --dataset-split-valid DATASET_SPLIT_VALID
                        dataset split to be used for validation ( ' validation ' as default)
  --lr LR [LR ...]      learning rate
  --random-seed RANDOM_SEED [RANDOM_SEED ...]
                        random seed
  -g GRADIENT_ACCUMULATION_STEPS [GRADIENT_ACCUMULATION_STEPS ...], --gradient-accumulation-steps GRADIENT_ACCUMULATION_STEPS [GRADIENT_ACCUMULATION_STEPS ...]
                        the number of gradient accumulation
  --weight-decay WEIGHT_DECAY [WEIGHT_DECAY ...]
                        coefficient of weight decay (set 0 for None)
  --lr-warmup-step-ratio LR_WARMUP_STEP_RATIO [LR_WARMUP_STEP_RATIO ...]
                        linear warmup ratio of learning rate (no decay).eg) if it ' s 0.3, the learning rate will warmup linearly till 30% of the total step
                        (set 0 for None)
  --max-grad-norm MAX_GRAD_NORM [MAX_GRAD_NORM ...]
                        norm for gradient clipping (set 0 for None)
  --crf CRF [CRF ...]   use CRF on top of output embedding (0 or 1)
  --optimizer-on-cpu    put optimizer on CPU to save memory of GPU
  --n-max-config N_MAX_CONFIG
                        the number of configs to run 2nd phase search
  --epoch-partial EPOCH_PARTIAL
                        the number of epoch for 1st phase search
  --max-length-eval MAX_LENGTH_EVAL
                        max length of language model at evaluation
  • Exemplo 
tner-train-search -m " roberta-large " -c " ckpt " -d " tner/wnut2017 " -e 15 --epoch-partial 5 --n-max-config 3 -b 64 -g 1 2 --lr 1e-6 1e-5 --crf 0 1 --max-grad-norm 0 10 --weight-decay 0 1e-7

Avaliando o modelo NER

A avaliação dos modelos NER é feita por model.evaluate Evaluar a função que leva dataset ou local_dataset como o conjunto de dados para avaliar. 

 from tner import TransformersNER
model = TransformersNER ( "tner/roberta-large-wnut2017" )  # provide model alias on huggingface
# huggingface dataset
metric = model . evaluate ( 'tner/wnut2017' , dataset_split = 'test' )
# local dataset
metric = model . evaluate ( local_dataset = { "test" : "examples/local_dataset_sample/test.txt" }, dataset_split = 'test' )

Um exemplo da metric do objeto de saída pode ser encontrado aqui.

Previsão de abrangência da entidade

Para uma melhor compreensão da precisão fora do domínio, fornecemos o pipeline de previsão de abrangência da entidade, que ignora o tipo de entidade e calcula métricas apenas na posição da entidade da IOB (marcação de sequência binária). 

 metric = model . evaluate ( datasets = 'tner/wnut2017' , dataset_split = 'test' , span_detection_mode = True )

Ferramenta de linha de comando

A ferramenta de linha de comando a seguir está disponível para previsão do modelo. 

tner-evaluate [-h] -m MODEL -e EXPORT [-d DATASET [DATASET ...]] [-l LOCAL_DATASET [LOCAL_DATASET ...]]
                     [--dataset-name DATASET_NAME [DATASET_NAME ...]] [--dataset-split DATASET_SPLIT] [--span-detection-mode] [--return-ci] [-b BATCH_SIZE]

Evaluate NER model

optional arguments:
  -h , --help            show this help message and exit
  -m MODEL, --model MODEL
                        model alias of huggingface or local checkpoint
  -e EXPORT, --export EXPORT
                        file to export the result
  -d DATASET [DATASET ...], --dataset DATASET [DATASET ...]
                        dataset name (or a list of it) on huggingface tner organization eg. ' tner/conll2003 ' [ ' tner/conll2003 ' , ' tner/ontonotes5 ' ]] see
                        https://huggingface.co/datasets ? search = tner for full dataset list
  -l LOCAL_DATASET [LOCAL_DATASET ...], --local-dataset LOCAL_DATASET [LOCAL_DATASET ...]
                        a dictionary (or a list) of paths to local BIO files eg.{ " train " : " examples/local_dataset_sample/train.txt " , " test " :
                        " examples/local_dataset_sample/test.txt " }
  --dataset-name DATASET_NAME [DATASET_NAME ...]
                        [optional] data name of huggingface dataset (should be same length as the ` dataset ` )
  --dataset-split DATASET_SPLIT
                        dataset split to be used for test ( ' test ' as default)
  --span-detection-mode
                        return F1 of entity span detection (ignoring entity type error and cast as binary sequence classification as below)- NER : [ " O " ,
                        " B-PER " , " I-PER " , " O " , " B-LOC " , " O " , " B-ORG " ]- Entity-span detection: [ " O " , " B-ENT " , " I-ENT " , " O " , " B-ENT " , " O " , " B-ENT " ]
  --return-ci           return confidence interval by bootstrap
  -b BATCH_SIZE, --batch-size BATCH_SIZE
                        batch size
  • Exemplo 
tner-evaluate -m " tner/roberta-large-wnut2017 " -e " metric.json " -d " tner/conll2003 " -b " 32 "

Referência

Se você usar algum desses recursos, cite o seguinte artigo: 

 @inproceedings{ushio-camacho-collados-2021-ner,
    title = "{T}-{NER}: An All-Round Python Library for Transformer-based Named Entity Recognition",
    author = "Ushio, Asahi  and
      Camacho-Collados, Jose",
    booktitle = "Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: System Demonstrations",
    month = apr,
    year = "2021",
    address = "Online",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/2021.eacl-demos.7",
    pages = "53--62",
    abstract = "Language model (LM) pretraining has led to consistent improvements in many NLP downstream tasks, including named entity recognition (NER). In this paper, we present T-NER (Transformer-based Named Entity Recognition), a Python library for NER LM finetuning. In addition to its practical utility, T-NER facilitates the study and investigation of the cross-domain and cross-lingual generalization ability of LMs finetuned on NER. Our library also provides a web app where users can get model predictions interactively for arbitrary text, which facilitates qualitative model evaluation for non-expert programmers. We show the potential of the library by compiling nine public NER datasets into a unified format and evaluating the cross-domain and cross- lingual performance across the datasets. The results from our initial experiments show that in-domain performance is generally competitive across datasets. However, cross-domain generalization is challenging even with a large pretrained LM, which has nevertheless capacity to learn domain-specific features if fine- tuned on a combined dataset. To facilitate future research, we also release all our LM checkpoints via the Hugging Face model hub.",
}
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos