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