def train_LM_model(corpus, model, n, gamma=None, unk_cutoff=2):
"""
Entraîne un modèle de langue n-gramme NLTK de la classe `model` sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param model: un des éléments de (MLE, Lidstone, Laplace)
:param n: int, l'ordre du modèle
:param gamma: float or None, le paramètre gamma (pour `model=Lidstone` uniquement). Si model=Lidstone, alors cet
argument doit être renseigné
:param unk_cutoff: le seuil au-dessous duquel un mot est considéré comme inconnu et remplacé par <UNK>
:return: un modèle entraîné
"""
lm = None
ngrams, words = padded_everygram_pipeline(n, corpus)
vocab = Vocabulary(words, unk_cutoff=unk_cutoff)
if model== MLE:
lm = model(n, vocabulary=vocab)
lm.fit(ngrams)
elif model == Lidstone:
if gamma == None:
raise Exception('Please enter a value for gamma')
else:
lm = Lidstone(gamma, order = n, vocabulary=vocab)
lm.fit(ngrams)
elif model==Laplace:
lm = Laplace(order = n, vocabulary=vocab)
lm.fit(ngrams)
else:
raise Exception('Wrong model in train_LM_model')
return lm
def train_LM_model(corpus, model, n, gamma=None, unk_cutoff=1):
"""
Entraîne un modèle de langue n-gramme NLTK de la classe `model` sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param model: un des éléments de (MLE, Lidstone, Laplace)
:param n: int, l'ordre du modèle
:param gamma: float or None, le paramètre gamma (pour `model=Lidstone` uniquement). Si model=Lidstone, alors cet
argument doit être renseigné
:param unk_cutoff: le seuil au-dessous duquel un mot est considéré comme inconnu et remplacé par <UNK>
:return: un modèle entraîné
"""
train, words = padded_everygram_pipeline(n, corpus.copy())
vocab = Vocabulary(words, unk_cutoff)
if (model == Lidstone) and (gamma is not None):
model = Lidstone(gamma,n,vocab)
model.fit(train)
elif model == MLE:
model = mle.train_MLE_model(corpus, n)
elif model == Laplace:
model = Laplace(n,vocab)
model.fit(train)
return model
def train_LM_model(corpus, model, n, gamma=None, unk_cutoff=2):
"""
Entraîne un modèle de langue n-gramme NLTK de la classe `model` sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param model: un des éléments de (MLE, Lidstone, Laplace)
:param n: int, l'ordre du modèle
:param gamma: float or None, le paramètre gamma (pour `model=Lidstone` uniquement). Si model=Lidstone, alors cet
argument doit être renseigné
:param unk_cutoff: le seuil au-dessous duquel un mot est considéré comme inconnu et remplacé par <UNK>
:return: un modèle entraîné
"""
#On veut condenser le corpus en une simple liste, pour pouvoir utiliser facilement Vocabulary
flat_corpus = []
for l in corpus:
for w in l:
flat_corpus.append(w)
vocab = Vocabulary(flat_corpus, unk_cutoff)
ngram_corpus = mnm.extract_ngrams(corpus,n)
if (model == MLE):
model_res = MLE(n)
model_res.fit(ngram_corpus, vocab)
if (model == Lidstone):
model_res = Lidstone(gamma,n)
model_res.fit(ngram_corpus, vocab)
if (model == Laplace):
model_res = Laplace(n)
model_res.fit(ngram_corpus, vocab)
return model_res
def train_LM_model(corpus, model, n, gamma=None, unk_cutoff=2):
"""
Entraîne un modèle de langue n-gramme NLTK de la classe `model` sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param model: un des éléments de (MLE, Lidstone, Laplace)
:param n: int, l'ordre du modèle
:param gamma: float or None, le paramètre gamma (pour `model=Lidstone` uniquement). Si model=Lidstone, alors cet
argument doit être renseigné
:param unk_cutoff: le seuil au-dessous duquel un mot est considéré comme inconnu et remplacé par <UNK>
:return: un modèle entraîné
"""
if model not in [MLE, Laplace, Lidstone]:
raise TypeError("Unkown model type! supported types: (MLE, Lidstone, Laplace)")
ngrams, words = padded_everygram_pipeline(n, corpus)
vocab = Vocabulary(words, unk_cutoff=unk_cutoff)
params = {
"order":n,
"vocabulary":vocab,
}
if model == Lidstone:
params["gamma"] = gamma
ist_model = model(**params)
ist_model.fit(ngrams)
return ist_model
def __init__(
self,
order,
vocabulary=None,
counter=None,
verbose=True,
):
"""Creates new LanguageModel.
:param vocabulary: If provided, this vocabulary will be used instead
of creating a new one when training.
:type vocabulary: `nltk.lm.Vocabulary` or None
:param counter: If provided, use this object to count ngrams.
:type vocabulary: `nltk.lm.NgramCounter` or None
:param ngrams_fn: If given, defines how sentences in training text are turned to ngram
sequences.
:type ngrams_fn: function or None
:param pad_fn: If given, defines how senteces in training text are padded.
:type pad_fn: function or None
"""
self.order = order
self.vocab = Vocabulary() if vocabulary is None else vocabulary
self.counts = NgramCounter() if counter is None else counter
def_dict_callable = partial(defaultdict, float)
self._cache = defaultdict(def_dict_callable)
self.verbose = verbose
def train_MLE_model(corpus, n):
"""
Entraîne un modèle de langue n-gramme MLE de NLTK sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param n: l'ordre du modèle
:return: un modèle entraîné
"""
ngrams, words = padded_everygram_pipeline(n, corpus)
vocab = Vocabulary(words, unk_cutoff=1)
lm = MLE(n, vocabulary=vocab)
lm.fit(ngrams)
return lm
def train_MLE_model(corpus, n):
"""
Entraîne un modèle de langue n-gramme MLE de NLTK sur le corpus.
:param corpus: list(list(str)), un corpus tokenizé
:param n: l'ordre du modèle
:return: un modèle entraîné
"""
# Creation of the vocabulary from the given corpus
flat_corpus = []
for document in corpus:
for word in document:
flat_corpus.append(word)
vocab = Vocabulary(flat_corpus, unk_cutoff=2)
# Extraction of the n-grams
n_grams = mnm.extract_ngrams(corpus, n)
# Creation and training of the model on the corpus
model = MLE(n, vocab)
model.fit(n_grams)
print("Modèle d'ordre", n, "généré par nltk.lm")
return model