Moses - FactoredTraining _ BuildingLanguageModelo_2

Prévia do material em texto

8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 1/14
Sistema de tradução
automática estatística
MOSES
1. Moisés
visão global
Manual 
Demonstrações Online
Perguntas frequentes
Listas de Discussão
 Se envolver
Mudanças recentes
2. Começando
Instalação de Origem
Sistema de linha de base
Pacotes
 Lançamentos
Dados de amostra
Links para Corpora
3. Tutoriais
Tutorial Baseado em
Frases
Tutorial de sintaxe
Tutorial Fatorado
 Otimizando Moisés
Experiment.Perl
4. Treinamento
visão global
Prepare dados de
treinamento
Treinamento Facturado
1 Preparar dados
2 Run GIZA
3 Alinhar palavras
4 tradução Lexical
5 extrair frases
6 frases de pontuação
7 Modelo de reordenação
8 modelo de geração
9 arquivo de configuração
 Modelos de linguagem
 Tuning
Referência de treinamento
Referência do
decodificador
5. Documentação do
usuário
Modelos Avançados
FactoredTraining » ConstruçãoLanguageModel
Construindo um Modelo de Linguagem
Conteúdo
- Language Models in Moses
- Ativando o Recurso LM OOV
- Construindo um LM com o SRILM Toolkit
- No IRSTLM Toolkit
- Compilando o IRSTLM
- Construindo Modelos de Linguagem Enormes
- Modelos de Linguagem Binários
- Modelos de Linguagem Quantizada
- Mapeamento de Memória
- Modelos de Linguagem de Classes e mais
- Chunk Language Models
- RandLM
- Instalando o RandLM
- Criando um modelo de linguagem randomizado
-Exemplo 1: Criando diretamente a partir de corpora
- Exemplo 2: Criando a partir de um arquivo ARPA (de outro kit de ferramentas)
- Exemplo 3: Criando um segundo modelo de idioma randomizado a partir dos mesmos dados
- Criando LMs Randomizados de 100 bilhões de palavras usando o Hadoop
- Consultando Modelos de Linguagem Aleatória
- KenLM
- Estimativa
- Usando o EMS
- Consulta
- Arquivo binário
- Carregamento completo ou lento
- Sondagem
- Trie
- Quantização
-Compactação de matriz (também conhecida como '' Chop '')
- Pesquisa de vocabulário
- OxLM
- NPLM
- Treinamento
- estimativas de custo futuras (palavra <null>)
- Consulta
- Uso em EMS
- LM neural bilingue
- Treinamento
- Consulta
- Uso em EMS
- N-gram LM (OSM) bilingue
- Treinamento
- Consulta
- Modelo OSM Interpolado
- Modelo de Linguagem de Dependência (RDLM)
- Treinamento
- Decodificação
Modelos de linguagem em Moisés
Procurar »
http://www.statmt.org/moses/index.php?n=Main.HomePage
http://www.statmt.org/moses/?n=Moses.Overview
http://www.statmt.org/moses/manual/manual.pdf
http://www.statmt.org/moses/manual/manual.pdf
http://www.statmt.org/moses/?n=Public.Demos
http://www.statmt.org/moses/?n=Moses.FAQ
http://www.statmt.org/moses/?n=Moses.MailingLists
http://www.statmt.org/moses/?n=Moses.GetInvolved
http://www.statmt.org/moses/?n=Main.Changes
http://www.statmt.org/moses/?n=Development.GetStarted
http://www.statmt.org/moses/?n=Moses.Baseline
http://www.statmt.org/moses/?n=Moses.Packages
http://www.statmt.org/moses/?n=Moses.Releases
http://www.statmt.org/moses/?n=Moses.SampleData
http://www.statmt.org/moses/?n=Moses.LinksToCorpora
http://www.statmt.org/moses/?n=Moses.Tutorial
http://www.statmt.org/moses/?n=Moses.SyntaxTutorial
http://www.statmt.org/moses/?n=Moses.FactoredTutorial
http://www.statmt.org/moses/?n=Moses.Optimize
http://www.statmt.org/moses/?n=FactoredTraining.EMS
http://www.statmt.org/moses/?n=FactoredTraining.HomePage
http://www.statmt.org/moses/?n=FactoredTraining.PrepareTraining
http://www.statmt.org/moses/?n=FactoredTraining.FactoredTraining
http://www.statmt.org/moses/?n=FactoredTraining.PrepareData
http://www.statmt.org/moses/?n=FactoredTraining.RunGIZA
http://www.statmt.org/moses/?n=FactoredTraining.AlignWords
http://www.statmt.org/moses/?n=FactoredTraining.GetLexicalTranslationTable
http://www.statmt.org/moses/?n=FactoredTraining.ExtractPhrases
http://www.statmt.org/moses/?n=FactoredTraining.ScorePhrases
http://www.statmt.org/moses/?n=FactoredTraining.BuildReorderingModel
http://www.statmt.org/moses/?n=FactoredTraining.BuildGenerationModel
http://www.statmt.org/moses/?n=FactoredTraining.CreateConfigurationFile
http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel
http://www.statmt.org/moses/?n=FactoredTraining.Tuning
http://www.statmt.org/moses/?n=FactoredTraining.TrainingParameters
http://www.statmt.org/moses/?n=Moses.DecoderParameters
http://www.statmt.org/moses/?n=Moses.AdvancedFeatures
http://www.statmt.org/moses/?n=Advanced.Models
http://www.statmt.org/moses/?n=FactoredTraining
http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 2/14
Armazenamento eficiente
de frase e regra
Pesquisa (decodificação)
Palavras desconhecidas
Tradução híbrida
Moisés como serviço
Treinamento Incremental
Adaptação de Domínio
Decodificação restrita
Modelos baseados em
cache
 Recursos esparsos
Ferramentas de suporte
Ferramentas Externas
Tradução da Web
Moses2
Linguagem de criação de
pipeline
Recursos obsoletos
6. Desenvolvimento
Vídeo
Guia de códigos
Estilo de Código
Fatores
Funções de recurso
Funções de recurso
esparso
Documentação de código
Testes de regressão
7. Antecedentes
MT estatístico
Glossário SMT
Modelos fatorados
Redes de Confusão
Grades de palavras
Publicações
O modelo de linguagem deve ser treinado em um corpus adequado ao domínio. Se o modelo de tradução for treinado em um corpus paralelo, o modelo de linguagem deve ser treinado no lado de saída desse
corpus, embora o uso de dados de treinamento adicionais seja geralmente benéfico.
Nosso decodificador funciona com os seguintes modelos de linguagem:
o kit de ferramentas de modelagem de linguagem SRI , que está disponível gratuitamente.
o kit de ferramentas de modelagem de linguagem IRST , que está disponível gratuitamente e é de código aberto.
o kit de ferramentas de modelagem de idiomas RandLM , que está disponível gratuitamente e de código aberto.
o kit de ferramentas de modelagem de idioma KenLM , que está incluído no Moses por padrão.
o kit de ferramentas de modelagem de idiomas DALM , que está disponível gratuitamente e de código aberto.
o kit de ferramentas de modelagem de linguagem OxLM , que está disponível gratuitamente e de código aberto.
o kit de ferramentas de modelagem de linguagem NPLM , que está disponível gratuitamente e de código aberto.
Para usar esses modelos de linguagem, eles precisam ser compilados com a opção apropriada:
--with-srilm = <diretório raiz do kit de ferramentas SRILM>
--with-irstlm = <diretório raiz do kit de ferramentas IRSTLM>
--with-randlm = <diretório raiz do kit de ferramentas RandLM>
--with-dalm = <diretório raiz do kit de ferramentas DALM>
--with-oxlm = <diretório raiz do kit de ferramentas OxLM>
--with-nplm = <diretório raiz do kit de ferramentas NPLM>
O KenLM é compilado por padrão. No arquivo de configuração do Moses, o tipo (SRI / IRST / RandLM / KenLM / DALM) do LM é especificado pela classe de função do recurso, por exemplo.
 [característica] 
 SRILM path = filename.srilm order = 3 .....
ou
 IRSTLM path = filename.irstlm ... 
ou
 RANDLM path = filename.irstlm ... 
ou
 KENLM path = filename.arpa ... 
ou
 DALM path = filename.dalm ... 
Todos os toolkits vêm com programas que criam um arquivo de modelo de idioma, conforme exigido pelo nosso decodificador. Os arquivos ARPA geralmente são trocáveis, portanto, você pode estimar com um
kit de ferramentas e consultar um diferente.
Ativando o Recurso LO OOV
Moisés oferece a opção de adicionar um recurso LM adicional que conta o número de ocorrências de palavras desconhecidas em uma hipótese. A maioria das implementações de modelos de linguagem em
Moisés suportam esse recurso. Para ativá-lo, adicione oov-feature=1à linha do modelo de idioma em moses.ini:
 ... LM path = ... oov-feature = 1 ... 
http://www.statmt.org/moses/?n=Advanced.RuleTables
http://www.statmt.org/moses/?n=Advanced.Search
http://www.statmt.org/moses/?n=Advanced.OOVs
http://www.statmt.org/moses/?n=Advanced.Hybrid
http://www.statmt.org/moses/?n=Advanced.Moseshttp://www.statmt.org/moses/?n=Advanced.Incremental
http://www.statmt.org/moses/?n=Advanced.Domain
http://www.statmt.org/moses/?n=Advanced.Constrained
http://www.statmt.org/moses/?n=Advanced.CacheBased
http://www.statmt.org/moses/?n=Moses.SparseFeatures
http://www.statmt.org/moses/?n=Moses.SupportTools
http://www.statmt.org/moses/?n=Moses.ExternalTools
http://www.statmt.org/moses/?n=Moses.WebTranslation
http://www.statmt.org/moses/?n=Site.Moses2
http://www.statmt.org/moses/?n=Advanced.PCL
http://www.statmt.org/moses/?n=Advanced.Obsolete
http://www.statmt.org/moses/?n=Moses.Video
http://www.statmt.org/moses/?n=Moses.CodeGuide
http://www.statmt.org/moses/?n=Moses.CodeStyle
http://www.statmt.org/moses/?n=Moses.CodeGuideFactors
http://www.statmt.org/moses/?n=Moses.FeatureFunctions
http://www.statmt.org/moses/?n=Moses.SparseFeatureFunctions
http://www.statmt.org/moses/html/hierarchy.html
http://www.statmt.org/moses/?n=Public.RegressionTests
http://www.statmt.org/moses/?n=Moses.Background
http://www.statmt.org/moses/glossary/SMT_glossary.html
http://www.statmt.org/moses/?n=Moses.FactoredModels
http://www.statmt.org/moses/?n=Moses.ConfusionNetworks
http://www.statmt.org/moses/?n=Moses.WordLattices
http://www.statmt.org/moses/?n=Moses.Publications
http://www.speech.sri.com/projects/srilm/
http://sourceforge.net/projects/irstlm/
http://sourceforge.net/projects/randlm/
http://kheafield.com/code/kenlm/
https://github.com/jnory/DALM
https://github.com/pauldb89/oxlm
https://github.com/moses-smt/nplm
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 3/14
Construindo um LM com o SRILM Toolkit
Um modelo de linguagem pode ser criado chamando:
 ngram-count -text CORPUS_FILE -lm SRILM_FILE 
O comando também funciona em gzentrada e saída compactadas ( ). Há uma variedade de switches que podem ser usados, recomendamos -interpolate -kndiscount.
No kit de ferramentas do IRSTLM
Moses também pode usar modelos de linguagem criados com o kit de ferramentas IRSTLM (veja Federico & Cettolo, (ACL WS-SMT, 2007) ). Os comandos descritos a seguir são fornecidos com o kit de
ferramentas IRSTLM que deve ser baixado e compilado separadamente.
O kit de ferramentas IRSTLM lida com formatos LM que permitem reduzir os requisitos de memória de armazenamento e decodificação e economizar tempo no carregamento do LM. Em particular, fornece
ferramentas para:
construção (enorme) LMs
Quantizing LMs
Compilando LMs (possivelmente quantizados) em um formato binário
acessando LMs binários através do mecanismo de mapeamento de memória
classe de consulta e LMs de partes
Compilando o IRSTLM
Compilar o IRSTLM requer:
 1. automake 1.9 ou superior 
 2. autoconf 2.59 ou superior 
 3. libtool 2.2.6 ou superior
Baixe o IRSTLM da seguinte maneira:
 wget http://sourceforge.net/projects/irstlm/files/irstlm/irstlm-5.80/irstlm-5.80.06.tgz/download
Descompacte o arquivo irstlm-5.80.06.tgz
 tar zxvf irstlm-5.80.06.tgz 
Para instalar o IRSTLM, siga as instruções relatadas no irstlm-5.80.06 / README.
Os binários e bibliotecas serão instalados no diretório de instalação, em bin / e lib /, respectivamente.
Construindo Modelos de Linguagem Enorme
Treinar um modelo de linguagem a partir de enormes quantidades de dados pode ser definitivamente um tempo de memória e caro. O kit de ferramentas IRSTLM apresenta algoritmos e estruturas de dados
adequados para estimar, armazenar e acessar LMs muito grandes. O IRSTLM é open source e pode ser baixado aqui .
Normalmente, a estimativa de LM começa com a coleta de n-gramas e seus contadores de frequência. Em seguida, os parâmetros de suavização são estimados para cada nível de n-grama; N-gramas
infrequentes são possivelmente removidos e, finalmente, um arquivo LM é criado contendo n-gramas com probabilidades e pesos de recuo. Este procedimento pode ser muito exigente em termos de memória e
tempo se aplicado a grandes corpora. O IRSTLM fornece uma maneira simples de dividir o treinamento LM em etapas menores e independentes, que podem ser distribuídas entre processos independentes.
O procedimento se baseia em um script de treinamento que faz pouco uso da memória do computador e implementa o método de suavização Witten-Bell. (Uma aproximação do método de suavização
modificado do Kneser-Ney também está disponível.) Primeiro, crie um diretório especial statsob seu diretório de trabalho, onde o script salvará muitos arquivos temporários; então, simplesmente execute o
script build-lm.sh como no exemplo:
 build-lm.sh -i "gunzip -c corpus.gz" -n 3 -o train.irstlm.gz -k 10 
http://www.aclweb.org/anthology-new/W/W07/W07-0712.pdf
http://sourceforge.net/projects/irstlm
http://sourceforge.net/projects/irstlm/files/irstlm/irstlm-5.80/irstlm-5.80.06.tgz/download
http://sourceforge.net/projects/irstlm
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 4/14
O script constrói um LM de 3 gramas (opção -n) a partir do comando de entrada especificado ( -i), dividindo o procedimento de treinamento em 10 etapas ( -k). O LM será salvo no -oarquivo output ( )
train.irstlm.gz com um intermediate ARPAformato. Esse formato pode ser gerenciado adequadamente por meio do compile-lmcomando para produzir um compiled versionou um padrão ARPA
version do LM.
Para uma descrição detalhada do procedimento e outros comandos disponíveis no IRSTLM, consulte o manual do usuário fornecido com o pacote.
Modelos de linguagem binária
Você pode converter seu arquivo de modelo de idioma (criado com o comando SRILM ngram-count ou com o kit de ferramentas IRSTLM) em um formato binário compacto com o comando:
 compile-lm language-model.srilm modelo de linguagem.blm 
Moses compilado com o kit de ferramentas IRSTLM é capaz de manipular adequadamente esse formato binário; a configuração moses.inipara esse arquivo é:
 Ordem IRSTLM = 3 fator = 0 caminho = idioma-model.blm 
O formato binário permite que os LMs sejam armazenados e carregados com eficiência. A implementação privilegia a economia de memória em vez do tempo de acesso.
Modelos de linguagem quantizada
Antes de compilar o modelo de linguagem, você pode quantizar (veja Federico & Bertoldi, (ACL WS-SMT, 2006) ) suas probabilidades e pesos de back-off com o comando:
 quantize-lm language-model.srilm linguagem-model.qsrilm 
Assim, o formato binário para este arquivo é gerado pelo comando:
 compile-lm language-model.qsrilm modelo de linguagem.qblm 
O modelo de idioma resultante requer menos memória porque todas as suas probabilidades e pesos de recuo são agora armazenados em 1 byte em vez de 4. Nenhuma configuração especial do arquivo de
configuração é necessária: Moisés compilado com o kit de ferramentas IRSTLM é capaz de ler as informações necessárias o cabeçalho do arquivo.
Mapeamento de Memória
É possível evitar o carregamento do LM na memória central, explorando o mecanismo de mapeamento de memória. O mapeamento de memória permite que o processo de decodificação acesse diretamente o
arquivo LM (binário) armazenado no disco rígido.
Aviso : Em caso de decodificação paralela em um cluster de computadores, cada processo acessará o mesmo arquivo. O possível número grande de solicitações de leitura pode sobrecarregar o driver do disco
rígido no qual o LM está armazenado e / ou a rede. Uma solução possível para tal problema é armazenar uma cópia do LM no disco local de cada nó de processamento, por exemplo, no diretório / tmp / .
Para ativar o acesso através do mapeamento de memória, basta adicionar o sufixo .mm ao nome do arquivo LM (que deve ser armazenado no formato binário) e atualizar o arquivo de configuração do Moses de
acordo.
Como exemplo, vamos supor que o 3gram LM foi construído e armazenado em formato binário no arquivo
 linguagem-model.blm 
Renomeie-o para adicionar o sufixo .mm :
 mv language-model.blm language-model.blm.mm 
ou crie um link simbólico nomeado corretamente para o arquivo original:
http://www.aclweb.org/anthology/W/W06/W06-31138/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 5/14
 ln -s language-model.blm linguagem-modelo.blm.mm 
Agora, a ativação do mecanismo de mapeamento de memória é obtida simplesmente atualizando o arquivo de configuração do Moses da seguinte forma:
 Ordem IRSTLM = 3 fator = 0 caminho = idioma-modelo.blm.mm 
Modelos de linguagem de classe e mais
Tipicamente, os LMs empregados por Moisés fornecem a probabilidade de n-gramas de fatores únicos. Além do modo padrão, o kit de ferramentas IRSTLM permite que Moses consulte os LMs de outras
maneiras diferentes. Na descrição a seguir, presume-se que o lado de destino dos textos de treinamento contém palavras que são concatenações de N>=1campos separados pelo caractere #. Similarmente aos
modelos fatorados, onde a palavra não é mais um simples símbolo, mas um vetor de fatores que podem representar diferentes níveis de anotação, aqui a palavra pode ser a concatenação de diferentes tags
para a forma de superfície de uma palavra, por exemplo:
 palavra # lema # parte do discurso # palavra-classe 
LMs específicos para cada tag podem ser consultados por Moses simplesmente adicionando um quarto parâmetro na linha do arquivo de configuração dedicado à especificação do LM. O parâmetro adicional é
um arquivo contendo (pelo menos) o seguinte cabeçalho:
 CAMPO <int> 
Possivelmente, também pode incluir um mapa um-para-um que é aplicado a cada componente de n-gramas antes da consulta LM:
 classe w1 (w1) 
 classe w2 (w2) 
 ... 
 classe wM (wM)
O valor de <int> determina o processamento aplicado aos componentes n-gram, que devem ser strings como field0#field1#...#fieldN:
-1: as cordas são usadas são elas; se o mapa é dado, ele é aplicado à string inteira antes da consulta LM
0-9: o número do campo <int> é selecionado; se o mapa é dado, é aplicado ao campo selecionado
00-99: os dois campos correspondentes aos dois dígitos são selecionados e concatenados juntos usando o caractere _como separador. Por exemplo, se <int> = 21, o LM é consultado com n-gramas de
strings field2_field1. Se o mapa é dado, ele é aplicado ao campo correspondente ao primeiro dígito.
O último caso é útil para a lexicalização de LMs: se os campos n. 2 e 1 correspondem ao POS e ao lema da palavra atual, respectivamente, o LM é consultado com n-gramas de POS_lemma.
Modelos de Linguagem Chunk
Um processamento específico é executado sempre que os campos devem corresponder a microtags , ou seja, as projeções por palavra de rótulos de partes . O processamento visa colapsar a sequência de
microtags que definem um pedaço para o rótulo daquele pedaço. O pedaço LM é então consultado com n-gramas de rótulos de pedaço, de maneira assíncrona com relação à sequência de palavras, já que em
geral os fragmentos consistem em mais palavras.
A operação de recolhimento é ativada automaticamente se a sequência de microtags for:
 (TAG TAG + TAG + ... TAG + TAG) 
ou
 TAG (TAG + TAG + ... TAG + TAG) 
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 6/14
Ambas as sequências são colapsadas em um rótulo de um único fragmento (digamos CHNK) desde que (TAG/ TAG(, TAG+e TAG)todas são mapeadas no mesmo rótulo CHNK. O mapa em rótulos diferentes ou
um uso / posição diferente de caracteres (, +e )no léxico de etiquetas de impedir a operação de colapso.
Atualmente (agosto de 2008), LMs de pedaços lexicalizados ainda estão sob investigação e apenas LMs de pedaços não lexicalizados são adequadamente manipulados; então, o intervalo de <int>valores
admitidos para este tipo de LMs é -1 ... 9, com o significado acima descrito.
RandLM
Se você realmente quer construir os maiores LMs possíveis (por exemplo, um 5-grama treinado em cem bilhões de palavras, então você deve olhar para o RandLM. Isto leva uma abordagem muito diferente
para o SRILM ou o IRSTLM. Ele representa LMs usando uma estrutura de dados randomizada (tecnicamente, variantes de filtros Bloom) .Isso pode resultar em LMs que são dez vezes menores do que aqueles
criados usando o SRILM (e também menores que IRSTLM), mas com o custo de fazer decodificação cerca de quatro vezes mais lento. é multithreaded agora, portanto, a redução de velocidade deve ser um
problema menor.
Detalhes técnicos de modelagem aleatória de linguagem podem ser encontrados em um documento do ACL (ver Talbot e Osborne, (ACL 2007) )
Instalando o RandLM
O RandLM está disponível no Sourceforge .
Depois de extrair a bola alcalina, vá para o diretório srce digite make.
Para integrar o RandLM em Moisés, por favor, veja acima.
Construindo um modelo de linguagem randomizado
O buildlmbinário (in randlm/bin) pré-processa e constrói modelos de linguagem randomizados.
O kit de ferramentas fornece três maneiras de construir modelos de linguagem aleatórios:
1. de um corpus tokenizado (isso é útil para arquivos com cerca de 100 milhões de palavras ou menos)
2. a partir de um modelo de linguagem de backoff pré-computado no formato ARPA (isso é útil se você quiser usar um modelo SRILM pré-computado)
3. de um conjunto de pares de contagem de ngram pré-computados (isso é útil se você precisar construir LMs de bilhões de palavras. O RandLM tem suporte a scripts do Hadoop).
O primeiro tipo de modelo será referido como um CountRandLM, enquanto o segundo será referido como um BackoffRandLM . Modelos construídos a partir de pares de contagem ngram pré-computados
também são do tipo "CountRandLM". Os CountRandLMs usam o StupidBackoff ou a suavização do Witten-Bell. Os modelos do BackoffRandLM podem usar qualquer esquema de suavização que o SRILM
implemente. Geralmente, o CountRandLMs é menor que o BackoffRandLMs, mas usa uma suavização menos sofisticada. Ao usar bilhões de palavras de material de treinamento, há menos necessidade de uma
boa suavização e, portanto, o CountRandLMs se torna apropriado.
Os seguintes parâmetros são importantes em todos os casos:
struct: A estrutura de dados randomizada usada para representar o modelo de idioma (atualmente somente BloomMape LogFreqBloomFilter).
order: A ordem do modelo n-gram, por exemplo, 3 para um modelo de trigramas.
falsepos: A taxa de falsos positivos da estrutura de dados aleatórios em uma escala de log inversa -falsepos 8produz uma taxa de falsos positivos de 1/2 
8
 .
values: O intervalo de quantização usado pelo modelo. Para uma quantização de CountRandLM é realizada tomando um logaritmo. A base do logaritmo é definida como 2 
1 /
values . Para um
BackoffRandLM, é utilizado um algoritmo de quantização binning. O tamanho do livro de códigos é definido como 2 values. Uma configuração razoável em ambos os casos é -values 8.
input-path: A localização dos dados a serem usados para criar o modelo de idioma.
input-type: O formato dos dados de entrada. Os quatro formatos a seguir são suportados
para um CountRandLM:
corpus corpora tokenised uma sentença por linha;
counts n-gram conta o arquivo (uma contagem e um n-grama por linha);
Dado um arquivo 'corpus', o kit de ferramentas criará um arquivo 'counts' que pode ser reutilizado (veja os exemplos abaixo).
para um BackoffRandLM:
arpa um modelo de linguagem backoff do ARPA;
backoff arquivo de modelo de idioma (dois carros alegóricos e um n grama por linha).
Dado um arpaarquivo, o kit de ferramentas criará um arquivo 'backoff' que pode ser reutilizado (veja os exemplos abaixo).
output-prefix: Prefixo adicionado a todos os arquivos de saída durante a construção de um modelo de linguagem aleatório.
Exemplo 1: Construindo diretamente de corpora
O comando
http://aclweb.org/anthology-new/P/P07/P07-1065.pdf
http://sourceforge.net/projects/randlm/
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 7/14
 ./buildlm -struct BloomMap -falsepos 8 -values 8 -modelo de prefixo de saída -order 3 <corpus 
produziria os seguintes arquivos:
 model.BloomMap <- o modelo de linguagemrandomizado 
 model.counts.sorted <- n-gram conta o arquivo 
 model.stats <- arquivo de estatísticas (contagens de contagens) 
 model.vcb <- arquivo de vocabulário (não necessário)
model.BloomMap: Este modelo de linguagem randomizado está pronto para ser usado sozinho (consulte 'Consultando um modelo de idioma aleatório' abaixo).
model.counts.sorted: Este é um arquivo no formato 'contagens' do RandLM com uma contagem seguida por um n-grama por linha. Ele pode ser especificado como mostrado no Exemplo 3 abaixo para
evitar a recomputação ao criar vários modelos de linguagem aleatória do mesmo corpus.
model.stats: Esse arquivo de estatísticas contém contagens de contagens e pode ser especificado por meio do parâmetro opcional '-statspath', conforme mostrado no Exemplo 3, para evitar a recomputação
ao criar vários modelos de idiomas aleatórios a partir dos mesmos dados.
Exemplo 2: Criando a partir de um arquivo ARPA (de outro kit de ferramentas)
O comando
 ./buildlm -struct BloomMap -falsepos 8 -values 8 -modelo de prefixo de saída - ordem 3 \ 
 -input-path precomputed.bo -input-type arpa
(onde precomputed.bocontém um modelo de backoff formatado em ARPA) produziria os seguintes arquivos:
 model.BloomMap <- o modelo de linguagem randomizado 
 model.backoff <- arquivo de backoff RandLM 
 model.stats <- arquivo de estatísticas (contagens de contagens) 
 model.vcb <- arquivo de vocabulário (não necessário)
model.backoffé uma cópia em formato RandLM do modelo ARPA. Pode ser reutilizado da mesma maneira que o model.counts.sortedarquivo (veja o Exemplo 3).
Exemplo 3: Construindo um segundo modelo de linguagem randomizado a partir dos mesmos dados
O comando
 ./buildlm -struct BloomMap -falsepos 4 -values 8 -output-prefix model4 -order 3 
 -input-path model.counts.sorted -input-type contagens -stats-path model.stats
construiria um novo modelo de linguagem randomizado ( model4.BloomMap) a partir dos mesmos dados usados no Exemplo 1, mas com uma taxa de erro diferente (aqui -falsepos 4). Esse uso evita a
tokenização do corpus e a recomputação do arquivo de estatísticas.
Construindo LMs Aleatórios de 100 Bilhões de Palavras usando o Hadoop
Em algum momento você descobrirá que não é possível construir um LM usando seus dados. RandLM usa nativamente um método baseado em disco para criar n-gramas e contagens, mas isso será lento para
grandes corpora. Em vez disso, você pode criar esses pares de contagem de ngram usando o Hadoop (Map-Reduce). A versão RandLM possui scripts Hadoop que pegam arquivos de texto bruto e criam
contagens de ngram. Nós construímos LMs aleatórios desta forma usando mais de 110 bilhões de tokens.
O procedimento para usar o Hadoop é o seguinte:
Primeiro você carrega arquivos de texto brutos e possivelmente tokenizados no Sistema de Arquivos Distribuídos Hadoop (DFS). Isso provavelmente envolverá comandos como:
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 8/14
 Hadoop dfs -put dados do myFile / 
Você então cria contagens de ngram usando o Hadoop (aqui um grama de 5 gramas):
 perl hadoop-lm-count.prl contagens de dados de dados 5 contagens de dados 
Você então faz o upload das contagens para o sistema de arquivos Unix:
perl hadoopRead.prl contagens de dados | gzip -> /unix/path/to/counts.gz 
Essas contagens podem então ser passadas para o RandLM:
 ./buildlm -stimator batch -smoothing WittenBell -ordem 5 \ 
 -valores 12 -struct LogFreqBloomFilter -tmp-dir / disk5 / miles \ 
 -output-prefixo giga3.rlm -output-dir / disk5 / milhas -falsepos 12 \ 
 -keep-tmp-files -sorted-by-ngram -contagens de tipo de entrada \ 
 -input-path /disk5/miles/counts.gz
Consultando Modelos de Idioma Aleatório
Moisés usa sua própria interface para o randLM, mas pode ser interessante consultar o modelo de linguagem diretamente. O querylmbinário (in randlm/bin) permite que um modelo de linguagem aleatório
seja consultado. A menos que especificado, as pontuações fornecidas pela ferramenta serão probabilidades de log condicionais (sujeitas a erros de aleatorização).
Os seguintes parâmetros estão disponíveis: -
randlm: O caminho do modelo de linguagem aleatória construído usando a buildlmferramenta conforme descrito acima.
test-path: A localização dos dados de teste a serem pontuados pelo modelo.
test-type: O formato dos dados de teste: atualmente corpuse ngramssão suportados. corpusirá tratar cada linha no arquivo de teste como uma sentença e fornecer pontuações para todos os n-
gramas (adicionando <s>e </s>). ngramsmarcará cada linha uma vez tratando cada um como um n-grama independente.
get-counts: Retorna as contagens de n-gramas em vez de probabilidades de log condicionais (suportadas apenas pelo CountRandLM).
checks: Aplica verificações sequenciais a n-gramas para evitar falsos positivos desnecessários.
Exemplo: o comando
 ./querylm -randlm model.BloomMap -test-path testfile -test-type ngrams -ordem 3> pontuações 
iria escrever probabilidades de log condicionais uma para cada linha no arquivo test-file.
Finalmente, você diz ao randLM para usar essas contagens pré-calculadas.
KenLM
O KenLM é um modelo de linguagem que é simultaneamente rápido e com pouca memória. As probabilidades retornadas são as mesmas do SRI, até o arredondamento de ponto flutuante. Ele é mantido por
Ken Heafield, que fornece informações adicionais em seu site , como benchmarks comparando velocidade e uso de memória com as outras implementações de modelos de linguagem. O KenLM é distribuído
com Moisés e compilado por padrão. KenLM é totalmente thread-safe para uso com Moses multi-threaded.
Estimativa
O programa lmplz estima modelos de linguagem com suavização Modified Kneser-Ney e sem poda. Passe a ordem (-o), uma quantidade de memória a ser usada para construir (-S) e um local para colocar
arquivos temporários (-T). Note que -S é compatível com a classificação GNU, por exemplo, 1G = 1 gigabyte e 80% significa 80% de RAM física. Ele é dimensionado para modelos muito maiores do que o
SRILM pode manipular e não recorre à aproximação como o IRSTLM faz.
 bin / lmplz -o 5 -S 80% -T / tmp <text> text.arpa 
http://kheafield.com/code/kenlm/
http://kheafield.com/code/kenlm/benchmark/
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 9/14
Veja a página sobre estimativa para mais.
Usando o EMS
Para usar o lmplz no EMS, configure os três parâmetros a seguir para suas necessidades e copie o quarto como está.
 # path to binário lmplz 
 lmplz = $ moses-bin-dir / lmplz 
 # ordem do modelo de linguagem 
 ordem = 3 
 # parâmetros adicionais para lmplz (verifique a mensagem de ajuda do lmplz) 
 configurações = "-T $ working-dir / tmp -S 10G" 
 # isso informa ao EMS para usar o lmplz e informa ao EMS onde o lmplz está localizado 
 lm-training = "$ moses-script-dir / genérico / trainlm-lmplz.perl -lmplz $ lmplz"
Consultando
Os arquivos ARPA podem ser lidos diretamente:
 Fator KENLM = <fator> ordem = <ordem> caminho = nome do arquivo.arpa 
mas o formato binário é carregado muito mais rápido e oferece mais flexibilidade. O campo <order> é ignorado. Em contraste, o SRI retorna silenciosamente probabilidades incorretas se você errar (as
probabilidades suavizadas de Kneser-Ney para gramas n-ordem inferiores são condicionadas ao recuo).
Arquivo binário
Usando o formato binário reduz significativamente o tempo de carregamento. Também expõe mais opções de configuração. O programa kenlm / build_binary converte arquivos ARPA em arquivos binários:
 kenlm / build_binary filename.arpa filename.binary 
Isto irá construir um arquivo binário que pode ser usado no lugar do arquivo ARPA. Note que, ao contrário do IRST, a extensão do arquivo não importa; o formato binário é reconhecido usando bytes mágicos.
Você também pode especificar a estrutura de dados a ser usada:
 kenlm / build_binary trie filename.arpa nome_do_arquivo.binary 
onde os valoresválidos são sondagem, classificados e trie. O padrão é sondar. Geralmente, eu recomendo usar sondagem se você tiver a memória e trie se você não tiver. Veja referências para detalhes. Para
determinar a quantidade de RAM que cada estrutura de dados levará, forneça apenas o arquivo arpa:
 kenlm / build_binary filename.arpa 
Tenha em mente que isso inclui apenas o tamanho do modelo de idioma, não a tabela de frases ou o estado do decodificador.
Construir o trie envolve uma classificação no disco. Você pode otimizar isso configurando a memória de classificação com -S usando as mesmas opções do tipo GNU, por exemplo, 100M, 1G, 80%. O modelo
final ainda usará a quantidade de memória necessária para armazenar o modelo. A opção -T permite personalizar onde colocar arquivos temporários (o padrão é baseado no nome do arquivo de saída).
 kenlm / build_binary -T / tmp / trio -S 1G trie nome do arquivo.arpa nome do arquivo.binário 
Carregamento completo ou lento
O KenLM suporta carregamento lento via mmap. Isso permite reduzir ainda mais o uso de memória, especialmente com trie que possui boa localização de memória. Isso é especificado por outros argumentos na
função de recurso para a função de recurso KENLM:
http://kheafield.com/code/kenlm/estimation/
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 10/14
 KENLM ... lazyken = <true / false> 
Eu recomendo carregar completamente se você tiver a RAM para isso; na verdade, leva menos tempo para carregar o modelo completo e usá-lo porque o disco não precisa procurar durante a decodificação. O
carregamento lento funciona melhor com o disco local e não é recomendado para sistemas de arquivos em rede.
Sondagem
O teste é a estrutura de dados mais rápida e padrão. Pesquisas Unigram acontecem por índice de matriz. Bigramas e n-gramas mais longos são divididos em números inteiros de 64 bits que têm probabilidade
muito baixa de colisão, mesmo com o ataque de aniversário . Esse hash de 64 bits é a chave para uma tabela de hash de sondagem em que os valores são probabilidade e backoff.
Uma tabela hash de sondagem linear é uma matriz que consiste em espaços em branco (zeros) e entradas com chaves diferentes de zero. A pesquisa prossegue codificando o módulo de chave o tamanho da
matriz, iniciando nesse ponto na matriz e digitalizando adiante até encontrar a entrada ou uma lacuna. A relação entre o tamanho do array e o número de entradas é controlada pelo parâmetro do multiplicador
de sondagem p. Esta é uma troca de espaço de tempo: o espaço é linear em peo tempo é O (p / (p-1)). O valor de p pode ser definido no tempo de construção binário, por exemplo
 kenlm / build_binary -p 1.2 sondagem nome_do_arquivo.arpa nome_do_arquivo.binário 
define um valor de 1,2. O valor padrão é 1.5, o que significa que um terço da matriz é em branco.
Trie
A estrutura de dados trie usa menos memória do que todas as outras opções (exceto RandLM com backoff estúpido), tem a melhor localização de memória e ainda é mais rápida que qualquer outro kit de
ferramentas. No entanto, demora mais para construir. Funciona da mesma maneira que a opção invertida do SRI e do IRST. Como a análise, a pesquisa de unigrama é um índice de matriz. Registros no trie têm
um índice de palavras, probabilidade, backoff e ponteiro. Todos os registros de n-gramas da mesma ordem são armazenados consecutivamente na memória. Um ponteiro de n-grama é, na verdade, o índice no
array (n + 1) -gram, onde o bloco de (n + 1) -grams com mais uma palavra do histórico é iniciado. O final desse bloco é encontrado lendo o ponteiro da próxima entrada. Registros dentro do bloco são
classificados por índice de palavras. Como os IDs de vocabulário são aleatoriamente permutados, uma distribuição de chave uniforme é aplicada. A pesquisa de interpolação em cada bloco encontra o índice de
palavras e sua probabilidade correspoding, backoff e ponteiro. O trie é compactado usando o número mínimo de bits para armazenar cada inteiro. A probabilidade é sempre não positiva, portanto, o bit de sinal
também é removido.
Como o trie armazena muitos ids de vocabulário e usa o número mínimo de bits para fazer isso, a filtragem de vocabulário é altamente eficaz para reduzir o tamanho geral do modelo mesmo se menos n-gramas
de ordem superior forem removidos.
Quantização
O trie suporta a quantização para qualquer número de bits de 1 a 25. Para quantizar até 8 bits, use -q 8. Se você quiser controlar separadamente a quantização de probabilidade e de backoff, use -q para
probabilidade e -b para backoff.
Compressão de matriz (também conhecida como Chop )
Os ponteiros trie compõem um array ordenado. Estes podem ser comprimidos usando uma técnica de Raj e Whittaker cortando bits e armazenando deslocamentos. A opção -a atua como um limite superior no
número de bits a serem cortados; nunca cortará mais bits do que minimiza o uso da memória. Como essa é uma troca de espaço de tempo (o tempo é linear no número de bits cortados), é possível configurar o
número limite superior de bits para cortar usando -a. Para minimizar a memória, use -a 64. Para economizar tempo, especifique um limite inferior, por exemplo, -a 10.
Pesquisa de vocabulário
As strings originais são mantidas no final do arquivo binário e passadas para Moisés em tempo de carregamento para obter ou gerar IDs de Moisés. É por isso que o carregamento binário lento ainda leva alguns
segundos. O KenLM armazena um mapeamento vetorial do ID de Moisés para o ID do KenLM. O custo deste vetor e o armazenamento de palavras do vocabulário do lado de Moisés não estão incluídos no uso
da memória relatado por build_binary. No entanto, os benchmarks relatam todo o custo da execução de Moisés.
OxLM
Por favor, consulte a documentação em https://github.com/pauldb89/oxlm
NPLM
O NPLM é um kit de ferramentas de modelo de linguagem de rede neural (homepage) . Atualmente, recomendamos a instalação de uma bifurcação que permita a pré-multiplicação da entrada incorporada e o
treinamento com uma única camada oculta para uma decodificação mais rápida.
Treinamento
[as etapas abaixo são automatizadas no script mosesdecoder / scripts / training / train-neurallm.py]
http://en.wikipedia.org/wiki/Birthday_attack
http://kheafield.com/code/kenlm/benchmark/
https://github.com/pauldb89/oxlm
http://nlg.isi.edu/software/nplm/
https://github.com/moses-smt/nplm
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 11/14
primeiro, prepare os dados de treinamento extraindo o vocabulário e convertendo-o em n-gramas numerados:
 prepareNeuralLM --train_text mydata.txt --ngram_size 5 \ 
 --vocab_size 100000 --write_words_file words \ 
 --train_file train.ngrams \ 
 --validation_size 500 --validation_file validation.ngrams
isso gera os arquivos train.ngrams, validation.ngrams e words.
então, treine a rede neural real. Esta etapa pode demorar muito e você pode precisar ajustar a quantidade de dados de treinamento ou o número de épocas de acordo.
 trainNeuralNetwork --train_file train.ngrams \ 
 --validation_file validation.ngrams \ 
 --num_epochs 10 \ 
 --words_file words \ 
 --model_prefix model \ 
 --input_embedding_dimension 150 \ 
 --num_hidden 0 \ 
 --output_embedding_dimension 750
Esta configuração corresponde aproximadamente às configurações descritas em (Vaswani et al. 2013) , exceto que '--num_hidden 0' resulta em um modelo com uma única camada oculta, o que é recomendado
para a integração do decodificador.
estimativas de custo futuras (<null> word)
Vaswani et al. (2013) recomendam o uso de palavras nulas especiais, que são a média ponderada de todas as inserções de entrada para preencher estimativas de ordem inferior. Para fazer isso, adicione <null>
ao arquivo devocabulário 'words' ( antes de treinar a rede) e execute o seguinte comando após o treinamento:
 mosesdecoder / scripts / treinamento / bilingue-lm / averageNullEmbedding.py \ 
 -p / caminho / para / nplm / python \ 
 -i input_model.nnlm \ 
 -o output_model.nnlm \ 
 -t train.ngrams
Consultando
para usar um modelo NPLM durante a decodificação, defina-o como uma função de recurso no arquivo de configuração do moses:
 [característica] 
 Fator NeuralLM = <fator> ordem = <ordem> caminho = nome do arquivo
Use no EMS
No mínimo, adicione o seguinte à [LM]seção de sua configuração do EMS:
 [LM: neural] 
 nplm-dir = / caminho / para / nplm / install 
 raw-corpus = / path / to / training / corpus 
 nplm = yes
Você pode usar as variáveis epochs, ordere nplm-settingspara configurar NPLM.
LM neural bilingue
http://nlg.isi.edu/software/nplm/vaswani-emnlp13.pdf
http://nlg.isi.edu/software/nplm/vaswani-emnlp13.pdf
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 12/14
Uma implementação de Devlin et al. (2014) , um modelo de linguagem de rede neural que usa um histórico do lado-alvo, bem como o contexto do lado da fonte, é implementado em Moses como BilingualLM. Ele
usa o NPLM como back-end (verifique suas instruções de instalação).
Treinamento
O BilingualLM requer um texto paralelo alinhado para treinamento. Ele usa as mesmas convenções de formato que o script do modelo de trem.
Primeiro, extraia os n-gramas numerados:
 mosesdecoder / scripts / treinamento / bilingue-lm / extract_training.py --working-dir <working_dir> \ 
 --corpus <corpus_file_prefix> \ 
 --source-language <L1> \ 
 - linguagem-alvo <L2> \ 
 --align <align_file.grow-diag-final-and> \ 
 --prune-target-vocab 100000 \ 
 --prune-source-vocab 100000 \ 
 --target-context 5 \ 
 --source-context 4 
essa configuração é para um modelo de linguagem de 5 gramas com 9 palavras de contexto de origem (a palavra de origem afiliada e uma janela de 4 palavras à esquerda e à direita) para um tamanho total de
n-grama de 14.
então, treine um modelo de rede neural:
 mosesdecoder / scripts / training / bilingue-lm / train_nplm.py \ 
 --working-dir <working_dir> \ 
 --corpus <corpus_file_prefix> \ 
 --nplm-home </ caminho / para / nplm> \ 
 - tamanho 14 
 - oculto 0 \ 
 --incorporação de saída 750 \ 
 --threads <number_of_threads>
'--hidden 0' resulta em uma rede neural com uma única camada oculta, que é recomendada para decodificação rápida de SMT.
por último, média a incorporação de palavra <nula> conforme as instruções aqui .
Consultando
para usar um modelo NPLM bilingue durante a decodificação, defina-o como uma função de recurso no arquivo de configuração do moses:
 [característica] 
 Ordem bilingueNPLM = 5 source_window = 4 caminho = / caminho / para / modelo source_vocab = / caminho / para / vocab.source target_vocab = / caminho / para /
os arquivos model, vocab.source e vocab.target estão todos no diretório de trabalho usado para treinar o LM bilingue.
Use no EMS
No mínimo, adicione o seguinte à [LM]seção de sua configuração do EMS:
 [LM: pente] 
 nplm-dir = / caminho / para / nplm / install 
 order = 5 
 janela de origem = 4 
 bilingue-lm = sim
http://acl2014.org/acl2014/P14-1/pdf/P14-1129.pdf
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 13/14
Você pode usar as variáveis epochspara definir as épocas de treinamento, bilingual-lm-settingspassar as configurações para o script de extração e nplm-settingscontrolar o treinamento do NPLM.
N-gram LM bilingue (OSM)
O Modelo de Sequência de Operação, como descrito em Durrani et al. (2011) e Durrani et al. (2013) é um modelo de linguagem bilíngue que também integra informações de reordenamento.
Para ativar o modelo OSM no decodificador baseado em frase, basta colocar o seguinte no arquivo de configuração do EMS:
 operação-seqüência-modelo = "sim" 
 ordem de modelo de sequência de operação = 5 
 operation-sequence-model-settings = ""
Se os dados foram aumentados com fatores adicionais, use (por exemplo)
 operation-sequence-model-settings = "--factor 0-0 + 1-1" 
"0-0" aprenderá o modelo OSM sobre as formas lexicais e "1-1" aprenderá o modelo OSM sobre o segundo fator (POS / Morph / Cluster-id etc.). O aprendizado de seqüências de operações sobre
representações generalizadas, como tags POS / Morph / classes de palavras, permite que o modelo supere a dispersão de dados Durrani et al. (2014) .
Se você quiser treinar o modelo OSM manualmente:
Treinamento
/path-to-moses/scripts/OSM/OSM-Train.perl --corpus-f corpus.fr --corpus-e corpus.en --alinhamento alinhado.grow-diag-final -e --ordem 5 - out-dir / caminho-para-experimento / modelo / OSM --moses-src-dir /
caminho-para-moses / --silm-dir / caminho-para-srilm / bin / i686-m64 - fator 0-0
Consultando
Adicionado ao modelo / moses.ini
[feature] 
... 
OpSequenceModel name = OpSequenceModel0 num-features = 5 path = / caminho-para-experimento / model / OSM / operationLM.bin 
... 
[peso] 
... 
OpSequenceModel0 = 0.08 -0.02 0.02 -0.001 0.03 
. ..
Modelo OSM interpolado
O modelo OSM treinado a partir da concatenação simples de dados no domínio com dados de vários domínios grandes e diversos é sub-ótimo. Quando outros domínios são suficientemente maiores e / ou
diferentes do que o domínio interno, a distribuição de probabilidade pode se desviar do domínio de destino, resultando em baixo desempenho. A natureza similar ao LM do modelo fornece motivação para aplicar
métodos como a otimização de perplexidade para ponderação de modelos. A idéia é treinar o modelo OSM em cada domínio separadamente e interpolá-los, otimizando a perplexidade no conjunto de ajuste
retido. Para saber mais leia Durrani et al. (2015) .
Uso
Forneça arquivos de ajuste como parâmetro adicional nas configurações. Por exemplo:
 interpolated-operation-sequence-model = "sim" 
 ordem de modelo de sequência de operação = 5 
 operation-sequence-model-settings = "--factor 0-0 --tune / caminho-para-tune-folder / tune_file --srilm-dir / caminho-para-srilm / bin / i686-m64"
http://aclweb.org/anthology//P/P11/P11-1105.pdf
http://aclweb.org/anthology/P/P13/P13-2071.pdf
http://www.statmt.org/OSMOSES/factor-v2.pdf
http://alt.qcri.org/~ndurrani/pubs/joint-models-domain.pdf
8/3/2019 Moses - FactoredTraining / BuildingLanguageModelo
www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel#ntoc6 14/14
Editar - História - ImprimirÚltima modificação da página, 01 de dezembro de 2015, às 16h18
Esse método requer o alinhamento de palavras para os arquivos de ajuste de origem e de referência para gerar sequências de operação. Isso pode ser feito usando decodificação de força do conjunto de ajuste
ou alinhando os conjuntos de afinação ao treinamento. A pasta deve conter arquivos como (por exemplo, (tune.de, tune.en, tune.align).
O script de interpolação não funciona com o LMPLZ e exigirá a instalação do SRILM.
Modelo de Linguagem de Dependência (RDLM)
RDLM (Sennrich 2015) é um modelo de linguagem para o decodificador string-to-tree com uma gramática de dependência. Ele deve funcionar com qualquer corpus com anotação de dependência projetiva no
formato ConLL, convertida no formato Moses com o script mosesdecoder / scripts / training / wrappers / conll2mosesxml.py. Depende do NPLM para treinamento e consulta de rede neural.
Treinamento
O RDLM é treinado em um corpus anotado com sintaxe de dependência. Os scripts de treinamento suportam o mesmo formato usado para treinar um modelo de conversão de string para árvore. Um exemplo de
EMS para o treinamento de string para dependência com Moisés é fornecido aqui . Para treinar o RDLM em dados monolíngües adicionais ou testá-lo em alguns dados de teste / desenvolvimento retidos,
analise-o e processe-o da mesma maneira que o corpus paralelo foiprocessado. Isso inclui tokenização, análise, truecoing, splitting composto etc.
O RDLM é dividido em dois modelos de redes neurais, que podem ser treinados com o train_rdlm.py. Um exemplo de comando para treinamento segue:
 mkdir working_dir_head 
 mkdir working_dir_label 
 mosesdecoder / scripts / treinamento / rdlm / train_rdlm.py --nplm-home / caminho / para / nplm --direção_de_diretório_de_direcionamento_do_trabalho \ 
 --output-dir / caminho / para /diretório_de_saída --diretório de saída -modelo rdlm_head \ 
 --mode head --output-vocab-size 500000 --noise-samples 100 
 mosesdecoder / scripts / treinamento / rdlm / train_rdlm.py --nplm-home / caminho / para / nplm --working-dir working_dir_label \ 
 --output-dir / caminho / para / output_directory --output-model rdlm_label \ 
 --mode label --output-vocab-size 75 --noise-samples 50 
para mais opções, execute train_rdlm.py --help. Os parâmetros que você pode querer ajustar incluem o tamanho do vocabulário e as camadas da rede neural e o número de épocas de treinamento.
Decodificação
Para usar o RDLM durante a decodificação, adicione a seguinte linha à sua configuração do moses.ini:
 [característica] 
 RDLM path_head_lm = / caminho / para / rdlm_head.model.nplm path_label_lm = / caminho / para / rdlm_label.model.nplm context_up = 2 context_left = 3
 
 [peso] 
 RDLM 0,1 0,1
 
http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel?action=edit
http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel?action=diff
http://www.statmt.org/moses/?n=FactoredTraining.BuildingLanguageModel?action=print
https://tacl2013.cs.columbia.edu/ojs/index.php/tacl/article/view/510
https://github.com/rsennrich/wmt2014-scripts/tree/master/example