print(ngram, proba_your_model, proba_nltk_model)
nb_total_difference+=1
return nb_total_difference/nb_total_ngrams
if __name__ == "__main__":
"""
Ici, vous devrez valider votre implémentation de `NgramModel` en la comparant avec le modèle NLTK. Pour n=1, 2, 3,
vous devrez entraîner un modèle nltk `MLE` et un modèle `NgramModel` sur `shakespeare_train`, et utiliser la fonction
`compare_models `pour vérifier qu'ils donnent les mêmes résultats.
Comme corpus de test, vous choisirez aléatoirement 50 phrases dans `shakespeare_train`.
"""
filename = "./data/shakespeare_train.txt"
preprocessed_corpus = read_and_preprocess(filename)
# Entrainement des differents modeles
nltk_model_1 = train_MLE_model(preprocessed_corpus, 1)
my_model_1 = NgramModel(preprocessed_corpus, 1)
nltk_model_2 = train_MLE_model(preprocessed_corpus, 2)
my_model_2 = NgramModel(preprocessed_corpus, 2)
nltk_model_3 = train_MLE_model(preprocessed_corpus, 3)
my_model_3 = NgramModel(preprocessed_corpus, 3)
# Compare si notre modele retourne les memes resultats que le modele nltk
print('Compare_models avec n=1')
error_1 = compare_models(my_model_1, nltk_model_1, preprocessed_corpus, 1)
print(error_1)
:param corpus: list(list(str)), une liste de phrases tokenizées à tester
:return: float, la proportion de n-grammes incorrects
"""
ngrams_count = len(your_model.counts)
faulty_ngrams_counts = 0
for context,next_words in your_model.counts.items():
for word,proba in next_words.items():
nltk_proba = nltk_model.score(word,context)
if nltk_proba != proba:
faulty_ngrams_counts+=1
print(f"\tdifferent probability found! context:{context} token:{word}, nltk_proba:{nltk_proba}, my_proba:{proba}")
print(f"\tratio of incorrect ngrams: {faulty_ngrams_counts * 1. /ngrams_count}")
return faulty_ngrams_counts * 1. /ngrams_count
if __name__ == "__main__":
"""
Ici, vous devrez valider votre implémentation de `NgramModel` en la comparant avec le modèle NLTK. Pour n=1, 2, 3,
vous devrez entraîner un modèle nltk `MLE` et un modèle `NgramModel` sur `shakespeare_train`, et utiliser la fonction
`compare_models `pour vérifier qu'ils donnent les mêmes résultats.
Comme corpus de test, vous choisirez aléatoirement 50 phrases dans `shakespeare_train`.
"""
corpus = read_and_preprocess("output/shakespeare_train_lemmes.txt")
for n in [1,2,3]:
print(f"[+] fitting models with n={n}")
nltk_model = train_MLE_model(corpus,n)
my_model = NgramModel(corpus,n)
compare_models(my_model, nltk_model, corpus, n)
print(get_most_frequent(corpus, 15))
print("Ratio: " + str(get_token_type_ratio(corpus)))
print("Nombre de lemmes distincts: " + str(count_lemmas(corpus)))
print("Nombre de racines (stems) distinctes: " + str(count_stems(corpus)))
if __name__ == "__main__":
"""
Ici, appelez la fonction `explore` sur `shakespeare_train` et `shakespeare_test`. Quand on exécute le fichier, on
doit obtenir :
>>> python explore_corpus
-- shakespeare_train --
Nombre de tokens: 5678
Nombre de types: 890
...
-- shakespeare_test --
Nombre de tokens: 78009
Nombre de types: 709
...
"""
print("-- shakespeare_train --")
corpus_shakespeare_train = pre.read_and_preprocess("data/shakespeare_train.txt")
explore(corpus_shakespeare_train)
print("-- shakespeare_test --")
corpus_shakespeare_test = pre.read_and_preprocess("data/shakespeare_test.txt")
explore(corpus_shakespeare_test)
print("Ration token/type: " + str(get_token_type_ratio(corpus)))
print("Nombre de lemmes: " + str(count_lemmas(corpus)))
print("Nombre de stems: " + str(count_stems(corpus)))
if __name__ == "__main__":
"""
Ici, appelez la fonction `explore` sur `shakespeare_train` et `shakespeare_test`. Quand on exécute le fichier, on
doit obtenir :
>>> python explore_corpus
-- shakespeare_train --
Nombre de tokens: 5678
Nombre de types: 890
...
-- shakespeare_test --
Nombre de tokens: 78009
Nombre de types: 709
...
"""
fileName = "shakespeare_train"
corpus = pre.read_and_preprocess("./data/" + fileName + ".txt")
print("--" + fileName + "--")
explore(corpus)
fileName = "shakespeare_test"
corpus = pre.read_and_preprocess("./data/" + fileName + ".txt")
print("--" + fileName + "--")
explore(corpus)
gamma. Vous pourrez appeler la fonction `evaluate_gamma` (déjà écrite) sur `shakespeare_train` et `shakespeare_test`
en faisant varier gamma dans l'intervalle (10^-5, 1) (question 1.5.3). Vous utiliserez une échelle logarithmique en
abscisse et en ordonnée.
Note : pour les valeurs de gamma à tester, vous pouvez utiliser la fonction `numpy.logspace(-5, 0, 10)` qui renvoie
une liste de 10 nombres, répartis logarithmiquement entre 10^-5 et 1.
3)
Enfin, pour chaque n=1, 2, 3, vous devrez générer 2 segments de 20 mots pour des modèles MLE entraînés sur Trump.
Réglez `unk_cutoff=1` pour éviter que le modèle ne génère des tokens <UNK> (question 1.6.2).
"""
print("#"*20, 'Question 1')
print('Loading data')
# Preprocess des deux corpus (train et test)
filename_train = "./data/shakespeare_train.txt"
preprocessed_corpus_train = read_and_preprocess(filename_train)
filename_test = "./data/shakespeare_test.txt"
preprocessed_corpus_test = read_and_preprocess(filename_test)
print("Done")
print()
# On entraine les modeles MLE et Laplace en faisant varier l'ordre
print("Fitting models with n=1")
mle_model_1 = train_LM_model(preprocessed_corpus_train, MLE, 1)
laplace_model_1 = train_LM_model(preprocessed_corpus_train, Laplace, 1)
print("Perplexity mle: ",evaluate(mle_model_1, preprocessed_corpus_test))
print("Perplexity Laplace: ",evaluate(laplace_model_1, preprocessed_corpus_test))
print()
print("Fitting models with n=2")
mle_model_2 = train_LM_model(preprocessed_corpus_train, MLE, 2)
print("nltk model proba: " + nltk_model.score(word, gram))
print('\n')
incorrect_ngram += 1.0
total_ngram += 1.0
return incorrect_ngram / total_ngram
if __name__ == "__main__":
"""
Ici, vous devrez valider votre implémentation de `NgramModel` en la comparant avec le modèle NLTK. Pour n=1, 2, 3,
vous devrez entraîner un modèle nltk `MLE` et un modèle `NgramModel` sur `shakespeare_train`, et utiliser la fonction
`compare_models `pour vérifier qu'ils donnent les mêmes résultats.
Comme corpus de test, vous choisirez aléatoirement 50 phrases dans `shakespeare_train`.
"""
corpus_shakespeare_train = preprocess_corpus.read_and_preprocess("data/shakespeare_train.txt")
with open("data/shakespeare_train.txt", "r") as f:
raw_text_shakespeare_train = f.read()
corpus_shakespeare_test = preprocess_corpus.segmentize(raw_text_shakespeare_train)
sentences = 0
list_sentences = []
corpus_test = []
while sentences < 50:
random_number = random.randint(0, len(corpus_shakespeare_test))
if random_number not in list_sentences:
corpus_test.append(corpus_shakespeare_test[random_number])
list_sentences.append(random_number)
sentences += 1
corpus_test = preprocess_corpus.tokenize(corpus_test)
gamma. Vous pourrez appeler la fonction `evaluate_gamma` (déjà écrite) sur `shakespeare_train` et `shakespeare_test`
en faisant varier gamma dans l'intervalle (10^-5, 1) (question 1.5.3). Vous utiliserez une échelle logarithmique en
abscisse et en ordonnée.
Note : pour les valeurs de gamma à tester, vous pouvez utiliser la fonction `numpy.logspace(-5, 0, 10)` qui renvoie
une liste de 10 nombres, répartis logarithmiquement entre 10^-5 et 1.
3)
Enfin, pour chaque n=1, 2, 3, vous devrez générer 2 segments de 20 mots pour des modèles MLE entraînés sur Trump.
Réglez `unk_cutoff=1` pour éviter que le modèle ne génère des tokens <UNK> (question 1.6.2).
"""
n = 3
fileName_train = "shakespeare_train"
fileName_test = "shakespeare_test"
corpus_train = pre.read_and_preprocess("./data/" + fileName_train + ".txt")
corpus_test = pre.read_and_preprocess("./data/" + fileName_test + ".txt")
print("Question 1")
for i in range(1,n+1):
print("n = "+ str(i))
MLE_model = train_LM_model(corpus_train, MLE, i)
LAPLACE_model = train_LM_model(corpus_train, Laplace, i,2)
print("perplexité du modèle MLE : " + str(evaluate(MLE_model,corpus_test)) \
+ " ,perplexité du modèle Laplace : " + str(evaluate(LAPLACE_model,corpus_test)))
print("Question 2")
for i in range(1,n+1):
en mesurant leur perplexité sur le corpus `shakespeare_test` (question 1.5.2).
2)
Ensuite, on vous demande de tracer un graphe représentant le perplexité d'un modèle Lidstone en fonction du paramètre
gamma. Vous pourrez appeler la fonction `evaluate_gamma` (déjà écrite) sur `shakespeare_train` et `shakespeare_test`
en faisant varier gamma dans l'intervalle (10^-5, 1) (question 1.5.3). Vous utiliserez une échelle logarithmique en
abscisse et en ordonnée.
Note : pour les valeurs de gamma à tester, vous pouvez utiliser la fonction `numpy.logspace(-5, 0, 10)` qui renvoie
une liste de 10 nombres, répartis logarithmiquement entre 10^-5 et 1.
3)
Enfin, pour chaque n=1, 2, 3, vous devrez générer 2 segments de 20 mots pour des modèles MLE entraînés sur Trump.
Réglez `unk_cutoff=1` pour éviter que le modèle ne génère des tokens <UNK> (question 1.6.2).
"""
corpus_shakespeare_train = preprocess_corpus.read_and_preprocess(
"data/shakespeare_train.txt")
corpus_shakespeare_test = preprocess_corpus.read_and_preprocess(
"data/shakespeare_test.txt")
for n in range(1, 4):
print("n= " + str(n))
mle_model = train_LM_model(corpus_shakespeare_train, MLE, n)
laplace_model = train_LM_model(corpus_shakespeare_train, Laplace, n)
print("Perplexite MLE= " +
str(evaluate(mle_model, corpus_shakespeare_test)))
print("Perplexite Laplace= " +
str(evaluate(laplace_model, corpus_shakespeare_test)))
lindston_perplexity = []
gamma_val = []
for gamma in np.logspace(-5, 0, 10):
