deep_srl

Rotulagem semântica profunda

Este repositório contém código para treinamento e usando o modelo SRL Deep descrito em: Rotulagem semântica profunda: o que funciona e o que vem a seguir

Se você usar nosso código, cite nosso papel da seguinte forma:

@InProedings {He2017Deep,
title = {Rotulagem de função semântica profunda: o que funciona e o que vem a seguir},
autor = {ele, Luheng e Lee, Kenton e Lewis, Mike e Zettlemoyer, Luke},
booktitle = {Anais da Reunião Anual da Associação para Linguística Computacional},
ano = {2017}
}

Começando

Pré -requisitos:

• O Python deve estar usando o Python 2. Você pode simular isso com o VirtualENV.
• pip install numpy
• pip install theano == 0.9.0 (compabilidade com o teano 1.0 ainda não foi testada)
• pip install protobuf
• pip install nltk (para tokenização, exigido apenas para o console interativo)
• sudo apt-get install tcsh (requerido apenas para o processamento de dados CONLL05)
• [Git Large File Storage] (https://git-lfs.github.com/): necessário para baixar os grandes arquivos de modelo. Como alternativa, você pode obter os modelos aqui
• INCLIMENTOS DE LOVA E OS SCRIPTS SRLCONLLL:
  ./scripts/fetch_required_data.sh

Modelos pré -teremam

Descompacte os modelos (em recursos) no diretório neural_srl. Por exemplo, no diretório CodeBase:
tar -zxvf resources/conll05_model.tar.gz

Aqui está uma lista de modelos pré -treinados:

• conll05_model.tar.gz : modelo único treinado no conjunto de dados CONLL-2005.
• conll05_ensemble.tar.gz : 5 Ensemble de modelo treinado no conjunto de dados CONLL-2005.
• conll05_propid_model.tar.gz : Modelo de identificação de predicado Trem no CONLL-2005.
• conll2012_model.tar.gz : modelo único treinado no conjunto de dados CONLL-2012.
• conll2012_ensemble.tar.gz : 5 Ensemble de modelo treinado no conjunto de dados CONLL-2012.
• conll2012_propid_model.tar.gz : Modelo de identificação de predicado Trem no CONLL-2012.

Experimente o console interativo!

python python/interactive.py --model conll05_model/ --pidmodel conll05_propid_model

Previsão de SRL de ponta a ponta:

Correr:
./scripts/run_end2end.sh sample_data/sentences_with_predicates.txt temp/sample.out (na CPU) ou:
./scripts/run_end2end.sh sample_data/sentences_with_predicates.txt temp/sample.out ${gpu_id} (na GPU)

Observe que o script adiciona /usr/local/cuda/... ao PATH e CUDA_LD_LIBRARY_PATH , e carrega modelos pré -gravados de ./conll05_propid_model e ./conll05_ensemble , por favor ajuste as configurações de acordo com sua própria configuração.

O arquivo de entrada contém frases tokenizadas, uma frase por linha.

O arquivo de saída conterá algo como:

John disse a Pat para cortar a árvore.
Predicado: dito (1)
A0: John
V: Disse
A2: Pat
A1: para cortar a árvore

John disse a Pat para cortar a árvore.
Predicado: corte (4)
A0: Pat
V: corte
A1: a árvore

Problema de escalabilidade

• A construção do modelo pela primeira vez pode demorar um pouco (menos de 30 minutos).
• Atualmente, predict.py carrega o arquivo de entrada inteiro na memória, por isso seria melhor manter o número de frases em cada arquivo abaixo de 50.000.

Dados Conll

Para replicar os resultados nos conjuntos de dados CONLL-2005 e CONLL-2012, siga as etapas abaixo.

CONLL-2005

Os dados são fornecidos por: tarefa compartilhada da CONLL-2005, mas as palavras originais são do conjunto de dados Penn Treebank, que não está disponível ao público. Se você tem o corpus PTB, pode executar:
./scripts/fetch_and_make_conll05_data.sh /path/to/ptb/

CONLL-2012

Você deve seguir as instruções abaixo para obter dados CONLL-2012 CONLL-2012, isso resultaria em um diretório chamado /path/to/conll-formatted-ontonotes-5.0 . Correr:
./scripts/make_conll2012_data.sh /path/to/conll-formatted-ontonotes-5.0

Prevendo SRL com modelo treinado

Veja o uso de python/train.py :
python python/predict.py -h

Ou como um início rápido, execute o modelo treinado (requer conll05_ensemble):
./scripts/run_predict_conll05.sh ${gpu_id} ou:
./scripts/run_predict_conll05.sh para executar na CPU.

Execute o modelo de ponta a ponta com previsto (requer conll05_ensemble e conll05_propid_model):
./scripts/run_end_to_end_conll05.sh ${gpu_id}

A execução do modelo CONLL-2012 funciona da mesma forma.

Treinando um novo modelo

Veja o uso de python/train.py :
python python/train.py -h

Treine um modelo SRL (com predicados de ouro) com arquivos de configuração predefinidos: ./scripts/run_train.sh ${gpu_id}

Treine um Predicado Identifider: ./scripts/run_propid_train.sh ${gpu_id}

Observe que, no horário do treinamento, train.py é executado no modelo FAST_RUN , o que resultará em uma enorme sobrecarga de compilação do modelo. Pode levar até alguns minutos para um modelo de 2 camadas e até 8 horas para um modelo de 8 camadas com abandono variacional.

Formato de dados

Consulte os arquivos em sample_data e as explicações abaixo para como formatar a entrada do modelo.

Formato de marcação de bio para o modelo SRL

Cada linha contém exatamente uma amostra de treinamento, que possui informações de predicado (índice nas frases, a partir de 0), a frase tokenizada e uma sequência de tags. Se as tags de ouro não existirem, basta usar uma sequência de OS. A frase e a sequência de tags são separadas com A ||| símbolo. Usamos o formato IOB2. Todos os tokens e símbolos são separados por um espaço de branco arbitrário.

Linhas de exemplo:

2 Meus gatos amam chapéus. ||| B-A0 I-A0 BV B-A1 O

Formato de marcação para o modelo de identificação de predicado

O formato é semelhante ao acima definido, exceto que cada linha corresponde a uma frase de entrada e nenhuma informação de predicado é fornecida. As prediadas correspondem às tags V e todas as outras palavras são rotuladas com tags O.

Linhas de exemplo:

Meus gatos amam chapéus, dizem eles. ||| Oovooovo

Configuração para treinamento.

config contém alguns arquivos de configuração para o treinamento do modelo SRL ( srl_config.json e srl_small_config.json ), bem como para treinar o modelo de predicado-ID ( propid_config.json )

Contato

Entre em contato com Luheng ele se tiver alguma dúvida!