Existe-t-il de bons modèles de langage prêts à l'emploi pour python?

Je prototype une application et j'ai besoin d'un modèle de langage pour calculer la perplexité sur certaines phrases générées.

Existe-t-il un modèle de langage formé en python que je peux facilement utiliser? Quelque chose de simple comme

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

J'ai regardé certains cadres mais je n'ai pas trouvé ce que je voulais. Je sais que je peux utiliser quelque chose comme:

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

Cela utilise une bonne distribution de probabilité de Turing sur Brown Corpus, mais je cherchais un modèle bien conçu sur un grand ensemble de données, comme l'ensemble de données 1b words. Quelque chose que je peux réellement faire confiance aux résultats pour un domaine général (pas seulement des nouvelles)

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
source

Tensorflow 1b mots LM

— user12075

Eh bien ce n'est pas du tout facilement utilisable mais c'est quelque chose. Merci :)

— Fred

C'est un modèle pré-formé que vous pouvez simplement télécharger et exécuter, et vous pensez qu'il n'est "pas du tout facilement utilisable" ...

— user12075

Je pense que vous et moi avons des définitions très différentes de ce que signifie "facilement utilisable" ... J'aurais besoin de comprendre comment obtenir les opérations de tensorflow que je veux (entrée et sortie) et comment elles se comportent, déterminer s'il y a un prétraitement pour ceci et ensuite envelopper le tout dans une fonction de perplexité. Je ne dis pas que je ne peux pas le faire, je dis simplement que ce n'est pas du tout la fonction "facilement utilisable" que j'ai montrée. Mais encore une fois, merci pour le pointeur

— Fred

Avez-vous essayé Google? J'entends qu'ils obtiennent une bonne quantité de données :) Je ne sais pas s'ils ont les mesures exactes que vous recherchez. cloud.google.com/natural-language/docs

— flyingmeatball

Réponses:

Le package spaCy a de nombreux modèles de langage , y compris ceux formés sur Common Crawl .

Le modèle de langage a une signification spécifique dans le traitement du langage naturel (NlP). Un modèle de langage est une distribution de probabilité sur des séquences de jetons. Étant donné une séquence spécifique de jetons, le modèle peut attribuer une probabilité d'apparition de cette séquence. Les modèles de langage de SpaCy incluent plus qu'une simple distribution de probabilité.

Le package spaCy doit être installé et les modèles de langue doivent être téléchargés:

$ pip install spacy 
$ python -m spacy download en

Ensuite, les modèles de langage peuvent être utilisés avec quelques lignes de Python:

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

Pour un modèle et un jeton donnés, il existe une estimation de probabilité log lissée du type de mot d'un jeton avec: token.probattribut.

— Brian Spiering
source

Supprimé mes commentaires précédents ... Apparemment, Spacy inclut un modèle de langage approprié (en utilisant l' token.probattribut), mais il n'est construit que dans la version grand modèle. Si vous modifiez votre réponse pour inclure cette information, je peux vous donner la prime. Assez drôle, j'utilise Spacy depuis des mois maintenant et nulle part j'ai vu qu'il avait cette fonctionnalité

— Fred

👍 Heureux que vous ayez trouvé quelque chose qui vous convient.

— Brian Spiering

Encore une fois .. Cela ne fonctionne que si vous téléchargez le grand modèle anglais

— Fred

Je pense que la réponse acceptée est incorrecte.

token.prob est le log-prob du token étant un type particulier. Je suppose que 'type' fait référence à quelque chose comme POS-tag ou type d'entité nommée (ce n'est pas clair dans la documentation de spacy) et le score est une mesure de confiance sur l'espace de tous les types.

Ce n'est pas la même chose que les probabilités attribuées par un modèle de langage. Un modèle de langage vous donne la distribution de probabilité sur tous les jetons possibles (pas le type) en disant lequel d'entre eux est le plus susceptible de se produire ensuite.

Ce dépôt a une documentation assez agréable sur l'utilisation de BERT (un modèle de pointe) avec des poids pré-formés pour le réseau neuronal,

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

Je pense que les API ne vous donnent pas directement la perplexité, mais vous devriez pouvoir obtenir assez facilement les scores de probabilité pour chaque jeton ( https://github.com/huggingface/pytorch-pretrained-BERT#usage ).

— noob333
source

Je pense également que la première réponse est incorrecte pour les raisons expliquées par @ noob333.

Mais Bert ne peut pas non plus être utilisé comme modèle de langage. Bert vous donne le p(word|context(both left and right) )et ce que vous voulez, c'est calculer p(word|previous tokens(only left contex)). L'auteur explique ici: https://github.com/google-research/bert/issues/35 pourquoi vous ne pouvez pas l'utiliser comme lm.

Cependant, vous pouvez adapter Bert et l'utiliser comme modèle de langage, comme expliqué ici: https://arxiv.org/pdf/1902.04094.pdf

Mais vous pouvez utiliser les modèles ouverts ai gpt ou gpt-2 pré-conservés du même dépôt ( https://github.com/huggingface/pytorch-pretrained-BERT )

Voici comment vous pouvez calculer la perplexité en utilisant le modèle 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

— gars
source