WordRepresentations
1.0.0
Esse benchmark experimental compara diferentes maneiras de representar palavras em uma tarefa simplificada de criar o modelo de idioma chamado.
Modelo de linguagem é uma maneira de calcular a probabilidade de um determinado fragmento do texto (cadeia de palavras). A PNL usou anteriormente várias opções para a construção de LM com base na contagem de gramas e suavização (suavização) para compensar a descarga para os n-gramas de arcos grandes. Por exemplo, o NLTK possui a implementação do método KNeser-ney. Há também um grande número de implementações diferentes que diferem nos detalhes técnicos sobre o armazenamento de grandes volumes de informações sobre n-gramer e a velocidade do processamento de texto, por exemplo, https://github.com/kpu/kenlm.
Nos últimos dois anos, diferentes opções para modelos de linguagem neural (NLMS) receberam uso generalizado, que usam várias arquiteturas neurosoteais, incluindo recorrente e brilho. O NLM pode ser dividido em dois grupos: trabalhando no nível das palavras (NLM com reconhecimento de palavras) e no nível dos caracteres (NLM com reconhecimento de caracteres). A segunda opção é especialmente interessante, pois permite que o modelo funcione com morfemas . Isso é extremamente significativo para idiomas com rica morfologia. Para algumas palavras, centenas de formas gramaticais podem existir potencialmente, como no caso de adjetivos na língua russa. Mesmo um caso de texto muito grande não garante que todas as variantes de formulários de palavras sejam incluídas no vocabulário do NLM com reconhecimento de palavras. Por outro lado, as estruturas morfêmicas quase sempre obedecem às regras regulares; portanto, o conhecimento da base ou da forma básica da palavra permite gerar suas opções gramaticais e semânticas: ousado, ousado, mordido, ousado etc., além de determinar a conexão semântica entre as mesmas palavras, mesmo que as palavras correspondentes sejam entrelaçadas para a primeira vez e as estatísticas e as estatísticas. A última observação se torna muito importante para os campos da PNL com uma formação dinâmica de palavras, antes de tudo, são todos os tipos de mídias sociais.
Dentro da estrutura da referência, todo o código necessário foi preparado para estudar e comparar as duas opções do NLM, juntamente com outros métodos de construção de consciência de LM-Characte e consciência de palavras.
Simplificaremos um pouco nosso modelo de langage, definindo a tarefa neste formulário. Há um n-grama de comprimento pré-selecionado (consulte a constante Ngram_order no módulo DataSetVectorizers). É obtido do caso de texto (o caminho para o arquivo UTF-8 com _Get_Corpus_Path BaseVectorizer da classe), então acreditamos que essa é uma combinação válida de palavras e o valor alvo y = 1. Se o n-grama for obtido por uma substituição aleatória de uma das palavras e uma cadeia não for encontrada no caso, então o alvo é y 0.
Os N-gramas inaceitáveis são gerados durante a análise do caso na mesma quantidade que válida. Acontece que um conjunto de dados equilibrado, que facilita a tarefa. E a falta da necessidade de marcas manuais permite que você "jogue" facilmente com um parâmetro como o número de registros no conjunto de dados de treinamento.
Assim, o problema de classificação binária é resolvido. O classificador será a implementação do gradiente que aumenta o XGBOOST e a rede neural, implementada no Keras, além de várias outras opções em diferentes linguagens de programação e estruturas DL.
O objeto do estudo é a influência do método de representar palavras na matriz de entrada X na precisão da classificação.
Uma análise detalhada de várias abordagens para a PNL, inclusive para tarefas semelhantes, pode ser encontrada no artigo: um iniciador sobre modelos de rede neural para processamento de linguagem natural.
As seguintes opções são verificadas quanto a XGboost:
W2V - Usamos o núcleo treinado word2vec, colando palavras de palavras em um longo vetor
W2V_TAGS - Expansão da representação W2V, categorias adicionais do vetor final são obtidas a partir de etiquetas morfológicas de palavras. Acontece que algo como modelo de linguagem fatorada
SDR - Representações distribuídas esparsas Palavras obtidas pela fatorização do modelo Word2Vector
Random_bitvector - Cada palavra é atribuída a um vetor de comprimento fixo binário aleatório com uma dada proporção de 0/1
BC - Os vetores criados como resultado do trabalho de cluster brown (consulte Descrição https://en.wikipedia.org/wiki/bron_clustering e a implementação https://github.com/percyliang/brunki) são usados como resultado
CARS - Cada palavra é codificada como uma cadeia de 1 -HOT Representação de Símbolos
Hashing_trick - Usado truque de hash para codificar palavras com um número limitado de bits de índice (consulte a descrição https://en.wikipedia.org/wiki/Feature_Hashing and Implementation https://radiMrehrethurek.com/Gensim/Corpora/hashdictionary.html)
AE - Palavras de palavras são obtidas como ativação na camada interna do autoencoder. O treinamento no autoencoder e os vetores de palavras é realizado pelo script word_autoncoder3.py na pasta Pymodels/wordautoEncoders.
Dois métodos de apresentação adicionais estão disponíveis para redes neurais, que são convertidas em uma determinada representação vetorial usando a camada de incorporação (ou semelhante à biblioteca usada usada.
Word_indeces - Um vocabulário é compilado, cada palavra recebe um índice inteiro exclusivo. Assim, o 3 grau parece ser um triplo de números inteiros.
Char_indeces - Um alfabeto é compilado, cada símbolo recebe um índice inteiro exclusivo. Além disso, as cadeias de índices de símbolos são complementadas por um índice de amostra com o mesmo comprimento (o comprimento máximo da palavra) e a cadeia resultante de índices de símbolo é retornada como a apresentação do n-gramas. Usando uma camada de incorporação (incorporação em keras ou similares), os símbolos são convertidos em uma forma de vetor densa com a qual o restante da rede neural funciona. Acontece que a versão do modelo de linguagem neural com reconhecimento de personagem.
Para resolver o problema, foram utilizadas várias bibliotecas de aprendizado de máquina, redes neurais e bibliotecas para computação matricial, incluindo:
Keras (com o back -end de Theano)
Lasanha (Theano)
Nolearn (Theano)
Tensorflow
Soluções Python:
Pymodels/wr_xgboost.py - Resolver com base no XGBOOST
Pymodels/wr_catboost.py - resolvedor de catboost nas palavras índices usando a capacidade de indicar índices de recursos categóricos no conjunto de dados para que o reforço os aprenda independentemente durante o treinamento
Pymodels/wr_keras.py - um resolvedor baseado em neurosetas de feed para avanço implementadas em keras
Pymodels/wr_keras_sdr2.py - uma solução separada para verificar a representação distribuída esparsa de uma grande dimensão (de 1024) com geração porções de matrizes para aprendizado e validação, em Keras. Pymodels/wr_lasagne.py - um resolvedor baseado em neurosetas de feed para a frente implementadas na lasanha (Theano)
Pymodels/wr_nolearn.py - um resolvedor baseado nas neurosetas de feed para a frente implementadas no nolearn+lasanha (teano)
Pymodels/wr_tensorflow.py - um solucionador baseado em neurosetas avançadas do Fed implementadas no tensorflow
Soluções em C#:
CSharpModels/WithAccordNet/Program.cs - Um resolvedor com base nas grades de feed para a Força Accord.net (C#, Projeto para VS 2015)
CSharpmodels/mybaseline/program.cs - Solução com base na minha implementação MLP de baunilha (C#, projeto para vs 2015)
Soluções no C ++:
Cxxmodels/tinydnn_model/tinydn_model.cpp - resolução MLP, implementada pela Library Tiny -dnn (C ++, projeto para vs 2015)
Cxxmodels/Singa_model/Alexnet.cc - Um resolvedor com base em uma rede neural implementada pelo Apache.singa (C ++, projeto para vs 2015)
Cxxmodels/opennn_model/main.cpp - um resolvedor baseado em um neurosetes, implementado pelo OpenNN (C ++, projeto para vs 2015)
Soluções sobre Java Javamodels/with4j/src/main/java/wordrepresentationstest.java - resolvedor de MLP, implementado pela Biblioteca DeePlearning4J
Classes e ferramentas internas:
Pymodels/corpusreaders.py - classes para leitura de linhas de edifícios de texto de diferentes formatos (Zipped | txt simples) pymodels/datasetVectorizers.py - vetorizadores de dados e fábrica para uma escolha conveniente
Pymodels/store_dataset_file.py - geração do conjunto de dados e sua preservação para modelos C# e C ++
Para redes neurais, dois arquitetos foram implementados com base em Keras. O MLP é um simples nefte de alimentação com camadas completas. Convnet é uma malha que usa camadas de pacote.
A comutação de arquiteturas é realizada por net_arch no parâmetro net_arch no arquivo wr_keras.py.
Pode -se notar que a opção com raiva geralmente fornece uma solução mais precisa, mas os modelos correspondentes têm uma variante maior, simplesmente coloque - a precisão final salta muito para vários modelos com os mesmos parâmetros.
Uma descrição detalhada da arquitetura e resultados numéricos dos experimentos podem ser encontrados aqui: https://kelijah.livejournal.com/224925.html.
Todas as opções de referência usam um arquivo de texto na codificação UTF-8 para receber listas de n-gramas. Supõe -se que a divisão do texto em palavras e trazendo para o registro inferior seja feita com antecedência por um terceiro código. Portanto, os scripts leem linhas deste arquivo, dividem -as em palavras por espaços.
Para a conveniência de reproduzir experimentos, coloquei uma exposição compactada de um grande estojo com um tamanho de 100 mil linhas na pasta de dados. Isso é suficiente para repetir todas as medidas. Para não sobrecarregar o repositório com um arquivo grande, ele é picado. O método BaseVectorizer._Load_Ngrams próprio desempacoteu seu conteúdo em tempo real, para que você não precise fazer nenhuma manipulação manual.
Na variante da vetorização de w2v_tags, as características morfológicas são adicionadas às veias W2V. Esses sinais para cada palavra são retirados do arquivo word2tags_bin.zip no subcatal de dados, que é obtido pela conversão do meu dicionário gramatical (http://solarix.ru/sql-dictionary-sdk.shtml). O resultado da conversão é atraído para 165 MB, o que é um pouco demais para o repositório Git. Portanto, gritei o arquivo resultante do dicionário gramatical e a classe correspondente de vetorização do próprio conjunto de dados o desempacotou em tempo real durante a operação.
Observe que, devido à homônima de formas gramaticais, muitas palavras têm mais de um conjunto de tags. Por exemplo, a palavra 'ursos' pode ser uma forma de um único ou plural, respectivamente, em um caso genitivo ou nominativo. Ao formar tags para palavras, combino tags de homônimos.
Um processo de dois estágios é usado. Primeiro, obtemos vetores de palavras W2V. Um pequeno script sobre os vetores do Python descarrega em um arquivo de texto no formato CSV.
Em seguida, usando o utilitário https://github.com/mfaruqui/sparse-coding, um comando é executado:
./nonneg.o input_vectors.txt 16 0,2 1e-5 4 out_vecs.txt
O arquivo out_vecs.txt que contém palavras SDR com os parâmetros indicados é gerado: size = 16*vetor w2v, preencher = 0.2 Este arquivo é carregado com a classe SDR_Vectorizer.
https://habrahabr.ru/post/335838/
http://kelijah.livejournal.com/217608.html
Como cheque, usamos a memorização dos n-gramas do conjunto de treinamento e a pesquisa entre os n-grams lembrados para o conjunto de testes. O pequeno tamanho do conjunto de treinamento leva ao fato de que, no conjunto de testes, o modelo se comporta simplesmente como um adivinhação aleatória, dando uma precisão de 0,50.
A tabela principal dos resultados está disponível no link. O restante dos seguintes resultados foi obtido para um conjunto de 1.000.000 3 gramas.
Para um resolvedor com base no XGBoost (wr_xgboost.py), foram obtidos os seguintes resultados.
Para um conjunto de dados contendo 1.000.000 TriGrams: W2V_TAGS (Word2Vector + Morph Tags) ==> 0,81
W2V (Word2Vector dim = 32) ==> 0,80
SDR (distribuído esparso representa, comprimento 512, 20% de unidades) ==> 0,78 aC (cluster brown) ==> 0,70
CHARS (CHAR ONE-HOT ENCODING) ==> 0,71
Random_bitvector (vetores de bits aleatórios, compartilhamento de unidades 16%) ==> 0,696
Hashing_trick (truque de hash com 32.000 slots) ==> 0,64
Para um solucionador baseado no MLP da lasanha:
Precisão = 0,71
Para um solucionador baseado no Nolearn+Lasagne MLP:
Precisão = 0,64
Para um resolvedor baseado no Tiny-DNN MLP:
Precisão = 0,58
Para um solucionador baseado no acordo de acordo com a rede neural para avanço:
Word2Vector ==> 0,68
Para uma resolução de catboost sobre as características categóricas do "Índice de palavras":
Precisão = 0,50
Para um solucionador baseado no apache.singa mlp:
Precisão = 0,74
Solução de linha de base - Memorizando N -Grams do conjunto de dados de treinamento
Precisão = 0,50
