pretraining for language understanding
1.0.0
Ahora, la capacitación previa del modelo de lenguaje para la comprensión del lenguaje es un paso significativo en el contexto de la PNL.
Un modelo de idioma estaría capacitado en un corpus masivo, y luego podemos usarlo como un componente en otros modelos que necesitan manejar el lenguaje (por ejemplo, usarlo para tareas aguas abajo).
Un modelo de lanugage (LM) captura la distribución sobre todas las oraciones posibles .
Si bien el modelado de idiomas es un aprendizaje típico no supervisado en un corpus masivo, lo convertimos en una secuencia de aprendizaje supervisado en este repositorio.
El modelo de lenguaje autorregresivo captura la distribución en el siguiente token se basa en todo el token anterior. En otras palabras, mira el token anterior y predice el siguiente token.
El objetivo del modelo de lenguaje autorregresivo se expresa en una fórmula de la siguiente manera:
Debido a que el modelo de lenguaje autorregresivo debe ser hacia adelante o hacia atrás, solo se puede utilizar información de contexto unidireccional unidireccional. Por lo tanto, es difícil entender el contexto en ambas direcciones simultáneamente.
RNNLM, ELMO es un ejemplo típico de modelo de lenguaje autorregresivo, y los modelos de lenguaje LSTM unidireccionales/bidireccionales están cubiertos en este repositorio.
Wikipedia distribuye regularmente todo el documento. Puede descargar el vertedero de Wikipedia coreano aquí (y el vertedero de Wikipedia en inglés aquí). Wikipedia recomienda usar pages-articles.xml.bz2 , que incluye solo la última versión de todo el documento, y está comprimido aproximadamente 600 MB (para inglés, pages-articles-multistream.xml.bz2 ).
Puede usar el script wikipedia_ko.sh para descargar el volcado en el último documento de Wikipedia coreano. Para inglés, use wikipedia_en.sh
ejemplo:
$ cd build_corpus
$ chmod 777 wikipedia_ko.sh
$ ./wikipedia_ko.sh
El volcado descargado usando el script de shell anterior está en formato XML, y necesitamos analizar XML para enviar un archivo de texto. El guión de Python WikiExtractor.py en Attardi/wikiextractor repo, extrae y limpia el texto del volcado.
ejemplo:
$ git clone https://github.com/attardi/wikiextractor
$ python wikiextractor/WikiExtractor.py kowiki-latest-pages-articles.xml
$ head -n 4 text/AA/wiki_02
<doc id="577" url="https://ko.wikipedia.org/wiki?curid=577" title="천문학">
천문학
천문학(天文學, )은 별이나 행성, 혜성, 은하와 같은 천체와, 지구 대기의 ..
</doc>
El texto extraído se guarda como archivo de texto de cierto tamaño. Para combinarlos, use build_corpus.py . La salida corpus.txt contiene 4,277,241 oraciones, 55,568,030 palabras .
ejemplo:
$ python build_corpus.py > corpus.txt
$ wc corpus.txt
4277241 55568030 596460787 corpus.txt
Ahora, debe dividir el corpus en el conjunto de tren y la prueba.
$ cat corpus.txt | shuf > corpus.shuf.txt
$ head -n 855448 corpus.shuf.txt > corpus.test.txt
$ tail -n 3421793 corpus.shuf.txt > corpus.train.txt
$ wc -l corpus.train.txt corpus.test.txt
3421793 corpus.train.txt
855448 corpus.test.txt
4277241 합계
Nuestro Corpus corpus.txt tiene 55,568,030 palabras y 608,221 palabras únicas. Si la frecuencia mínima necesaria para incluir un token en el vocabulario se establece en 3, el vocabulario contiene 297,773 palabras únicas.
Aquí usamos el Train Corpus corpus.train.txt para construir vocabulario. El vocabulario construido por Train Corpus contiene 557,627 palabras únicas y 271,503 palabras únicas que aparecen al menos tres veces.
ejemplo:
$ python build_vocab.py --corpus build_corpus/corpus.train.txt --vocab vocab.train.pkl --min_freq 3 --lower
Namespace(bos_token='<bos>', corpus='build_corpus/corpus.train.txt', eos_token='<eos>', is_tokenized=False, lower=True, min_freq=3, pad_token='<pad>', tokenizer='mecab', unk_token='<unk>', vocab='vocab.train.pkl')
Vocabulary size: 271503
Vocabulary saved to vocab.train.pkl
Dado que el archivo de vocabulario es demasiado grande (~ 1.3GB) para cargar en este repositorio, lo subí a Google Drive.
vocab.train.pkl : [Descargar] $ python lm_trainer.py -h
usage: lm_trainer.py [-h] --train_corpus TRAIN_CORPUS --vocab VOCAB
--model_type MODEL_TYPE [--test_corpus TEST_CORPUS]
[--is_tokenized] [--tokenizer TOKENIZER]
[--max_seq_len MAX_SEQ_LEN] [--multi_gpu] [--cuda CUDA]
[--epochs EPOCHS] [--batch_size BATCH_SIZE]
[--clip_value CLIP_VALUE] [--shuffle SHUFFLE]
[--embedding_size EMBEDDING_SIZE]
[--hidden_size HIDDEN_SIZE] [--n_layers N_LAYERS]
[--dropout_p DROPOUT_P]
optional arguments:
-h, --help show this help message and exit
--train_corpus TRAIN_CORPUS
--vocab VOCAB
--model_type MODEL_TYPE
Model type selected in the list: LSTM, BiLSTM
--test_corpus TEST_CORPUS
--is_tokenized Whether the corpus is already tokenized
--tokenizer TOKENIZER
Tokenizer used for input corpus tokenization
--max_seq_len MAX_SEQ_LEN
The maximum total input sequence length after
tokenization
--multi_gpu Whether to training with multiple GPU
--cuda CUDA Whether CUDA is currently available
--epochs EPOCHS Total number of training epochs to perform
--batch_size BATCH_SIZE
Batch size for training
--clip_value CLIP_VALUE
Maximum allowed value of the gradients. The gradients
are clipped in the range
--shuffle SHUFFLE Whether to reshuffle at every epoch
--embedding_size EMBEDDING_SIZE
Word embedding vector dimension
--hidden_size HIDDEN_SIZE
Hidden size of LSTM
--n_layers N_LAYERS Number of layers in LSTM
--dropout_p DROPOUT_P
Dropout rate used for dropout layer in LSTM
ejemplo:
$ python lm_trainer.py --train_corpus build_corpus/corpus.train.txt --vocab vocab.train.pkl --model_type LSTM --batch_size 16
Puede seleccionar sus propios valores de parámetros a través de entradas de argumentos.
Entrenar un modelo con GPU único no solo es muy lento, sino que también limita el tamaño del lote de ajuste, el tamaño del modelo, etc. Para acelerar el entrenamiento de modelos con múltiples GPU y usar un modelo grande, lo que tiene que hacer es incluir la bandera --multi_gpu como Bloods. Para más detalles, consulte aquí.
Este código de ejemplo entrena el modelo unidireccional-LSTM en el Corpus de Wikipedia utilizando entrenamiento paralelo en GPU 8 * V100.
$ python lm_trainer.py --train_corpus build_corpus/corpus.train.txt --vocab vocab.train.pkl --model_type LSTM --multi_gpu
Namespace(batch_size=512, clip_value=10, cuda=True, dropout_p=0.2, embedding_size=256, epochs=10, hidden_size=1024, is_tokenized=False, max_seq_len=32, model_type='LSTM', multi_gpu=True, n_layers=3, shuffle=True, test_corpus=None, tokenizer='mecab', train_corpus='build_corpus/corpus.train.txt', vocab='vocab.train.pkl')
=========MODEL=========
DataParallelModel(
(module): LSTMLM(
(embedding): Embedding(271503, 256)
(lstm): LSTM(256, 1024, num_layers=3, batch_first=True, dropout=0.2)
(fc): Linear(in_features=1024, out_features=512, bias=True)
(fc2): Linear(in_features=512, out_features=271503, bias=True)
(softmax): LogSoftmax()
)
)
Este ejemplo de código entrena al modelo bidireccional-LSTM en el Corpus de Wikipedia utilizando entrenamiento paralelo en 8 * V100 GPU.
$ python lm_trainer.py --train_corpus build_corpus/corpus.train.txt --vocab vocab.train.pkl --model_type BiLSTM --n_layers 1 --multi_gpu
Namespace(batch_size=512, clip_value=10, cuda=True, dropout_p=0.2, embedding_size=256, epochs=10, hidden_size=1024, is_tokenized=False, max_seq_len=32, model_type='BiLSTM', multi_gpu=True, n_layers=1, shuffle=True, test_corpus=None, tokenizer='mecab', train_corpus='build_corpus/corpus.train.txt', vocab='vocab.train.pkl')
=========MODEL=========
DataParallelModel(
(module): BiLSTMLM(
(embedding): Embedding(271503, 256)
(lstm): LSTM(256, 1024, batch_first=True, dropout=0.2, bidirectional=True)
(fc): Linear(in_features=2048, out_features=1024, bias=True)
(fc2): Linear(in_features=1024, out_features=512, bias=True)
(fc3): Linear(in_features=512, out_features=271503, bias=True)
(softmax): LogSoftmax()
)
)
Un modelo de idioma captura la distribución sobre todas las oraciones posibles. Y, el mejor modelo de idioma es uno que el mejor predice una oración invisible. Perplexty es una medición muy común de qué tan bien una distribución de probabilidad predice oraciones invisibles.
Perlexidad : probabilidad inversa de la oración dada, normalizada por el número de palabras (tomando la media geométrica)
Como puede ver en la ecuación anterior, la perplejidad se define como la probabilidad promedio negativa exponencial de log. En otras palabras, maximizar la probabilidad es la misma que minimizar la perplejidad.
Y ahora, la perplejidad es la métrica que vamos a usar. Una baja perplejidad indica que la distribución de probabilidad es buena para predecir la oración.
| Modelo | Pérdida | Perplejidad |
|---|---|---|
| Unidireccional-lstm | 3.496 | 33.037 |
| Bidireccional-LSTM | 1.896 | 6.669 |
| Bidireccional-LSTM-LARGE ( Hidden_Size = 1024) | 1.771 | 5.887 |
