Existem bons modelos de linguagem prontos para uso em python?

Estou prototipando um aplicativo e preciso de um modelo de linguagem para calcular a perplexidade em algumas frases geradas.

Existe algum modelo de linguagem treinado em python que eu possa usar facilmente? Algo simples como

model = LanguageModel('en')
p1 = model.perplexity('This is a well constructed sentence')
p2 = model.perplexity('Bunny lamp robert junior pancake')
assert p1 < p2

Eu olhei para algumas estruturas, mas não consegui encontrar o que quero. Eu sei que posso usar algo como:

from nltk.model.ngram import NgramModel
lm = NgramModel(3, brown.words(categories='news'))

Isso usa uma boa distribuição de probabilidade de turing no Brown Corpus, mas eu estava procurando por um modelo bem trabalhado em alguns grandes conjuntos de dados, como o conjunto de dados 1b words. Algo em que posso confiar nos resultados de um domínio geral (não apenas notícias)

python nlp language-model r statistics linear-regression machine-learning classification random-forest xgboost python sampling data-mining orange predictive-modeling recommender-system statistics dimensionality-reduction pca machine-learning python deep-learning keras reinforcement-learning neural-network image-classification r dplyr deep-learning keras tensorflow lstm dropout machine-learning sampling categorical-data data-imputation machine-learning deep-learning machine-learning-model dropout deep-network pandas data-cleaning data-science-model aggregation python neural-network reinforcement-learning policy-gradients r dataframe dataset statistics prediction forecasting r k-means python scikit-learn labels python orange cloud-computing machine-learning neural-network deep-learning rnn recurrent-neural-net logistic-regression missing-data deep-learning autoencoder apache-hadoop time-series data preprocessing classification predictive-modeling time-series machine-learning python feature-selection autoencoder deep-learning keras tensorflow lstm word-embeddings predictive-modeling prediction machine-learning-model machine-learning classification binary theory machine-learning neural-network time-series lstm rnn neural-network deep-learning keras tensorflow convnet computer-vision

— Fred
fonte

Tensorflow 1b palavras LM

— user12075

Bem, isso não é facilmente utilizável, mas é algo. Obrigado :)

— Fred

Esse é um modelo pré-treinados que você pode simplesmente baixar e executar, e você acha que "não é de todo facilmente utilizáveis" ...

— user12075

Eu acho que você e eu temos definições muito diferentes do que "prontamente utilizável" significa ... Eu precisaria descobrir como obter as operações de tensorflow que eu quero (entrada e saída) e como elas se comportam, descobrir se há algum pré-processamento para isso e, em seguida, envolva tudo em alguma função de perplexidade. Não estou dizendo que não posso fazer isso, apenas estou dizendo que não é de todo a função "prontamente utilizável" que mostrei. Mas, novamente, graças para o ponteiro

— Fred

Já experimentou o google? Ouvi dizer que eles obtêm uma quantidade razoável de dados :) Não tenho certeza se eles têm as métricas exatas que você procura. cloud.google.com/natural-language/docs

— flyingmeatball 24/09

Respostas:

O pacote spaCy possui muitos modelos de idiomas , incluindo os treinados no Common Crawl .

O modelo de linguagem tem um significado específico no Processamento de linguagem natural (PNL). Um modelo de linguagem é uma distribuição de probabilidade através de sequências de tokens. Dada uma sequência específica de tokens, o modelo pode atribuir uma probabilidade dessa sequência aparecer. Os modelos de linguagem da SpaCy incluem mais do que apenas uma distribuição de probabilidade.

O pacote spaCy precisa ser instalado e os modelos de idiomas precisam ser baixados:

$ pip install spacy 
$ python -m spacy download en

Em seguida, os modelos de linguagem podem ser usados com algumas linhas do Python:

>>> import spacy
>>> nlp = spacy.load('en')

Para um determinado modelo e token, há uma estimativa de probabilidade de log suavizada do tipo de palavra de um token que pode ser encontrada com: token.probattribute.

— Brian Spiering
fonte

Excluiu meus comentários anteriores ... Aparentemente, o spacy inclui um modelo de linguagem adequado (usando o token.probatributo), mas é construído apenas na versão de modelo grande. Se você editar sua resposta para incluir essas informações, eu posso lhe dar uma recompensa. Engraçado o suficiente, eu tenho usado spacy por meses agora e vi nenhum lugar que eu que tinha esse recurso

— Fred

👍 Que bom que você encontrou algo que funciona para você.

— Brian Spiering

Novamente .. Isso só funciona se você baixar o modelo em inglês grande

— Fred

Eu acho que a resposta aceita está incorreta.

token.prob é o log-prob do token sendo um tipo específico. Suponho que 'type' se refira a algo como tag POS ou tipo de entidade nomeada (não está claro na documentação do spacy) e a pontuação é uma medida de confiança no espaço de todos os tipos.

Isso não é o mesmo que as probabilidades atribuídas por um modelo de linguagem. Um modelo de linguagem fornece a distribuição de probabilidade entre todos os tokens possíveis (não o tipo), dizendo qual deles é mais provável que ocorra a seguir.

Esse repositório possui uma documentação bastante interessante sobre o uso do BERT (um modelo de ponta) com pesos pré-treinados para a rede neural,

BERT, https://github.com/huggingface/pytorch-pretrained-BERT

Acho que as APIs não causam perplexidade diretamente, mas você deve conseguir pontuações de probabilidade para cada token com bastante facilidade ( https://github.com/huggingface/pytorch-pretrained-BERT#usage ).

— noob333
fonte

Também acho que a primeira resposta está incorreta pelas razões que o @ noob333 explicou.

Mas também Bert não pode ser usado imediatamente como modelo de linguagem. Bert fornece p(word|context(both left and right) )e o que você deseja é calcular p(word|previous tokens(only left contex)). O autor explica aqui: https://github.com/google-research/bert/issues/35 por que você não pode usá-lo como um filme.

No entanto, você pode adaptar o Bert e usá-lo como modelo de linguagem, conforme explicado aqui: https://arxiv.org/pdf/1902.04094.pdf

Mas você pode usar os modelos abertos ai gpt ou gpt-2 pré-definidos no mesmo repositório ( https://github.com/huggingface/pytorch-pretrained-BERT )

Aqui está como você pode calcular a perplexidade usando o modelo gpt ( https://github.com/huggingface/pytorch-pretrained-BERT/issues/473 )

import math
from pytorch_pretrained_bert import OpenAIGPTTokenizer, OpenAIGPTModel, OpenAIGPTLMHeadModel
# Load pre-trained model (weights)
model = OpenAIGPTLMHeadModel.from_pretrained('openai-gpt')
model.eval()
# Load pre-trained model tokenizer (vocabulary)
tokenizer = OpenAIGPTTokenizer.from_pretrained('openai-gpt')

def score(sentence):
    tokenize_input = tokenizer.tokenize(sentence)
    tensor_input = torch.tensor([tokenizer.convert_tokens_to_ids(tokenize_input)])
    loss=model(tensor_input, lm_labels=tensor_input)
    return math.exp(loss)


a=['there is a book on the desk',
                'there is a plane on the desk',
                        'there is a book in the desk']
print([score(i) for i in a])
21.31652459381952, 61.45907380241148, 26.24923942649312

— rapazes
fonte