Faculté des Sciences de Monastir A.

U : 2021-22
Département Informatique LSI2 Enseignant : S. Belaid

TP3 : Recherche d'information

I. Google Colab :
Google Colab ou Colaboratory est un service cloud, offert par Google (gratuit), basé sur
Jupyter Notebook et destiné à la formation et à la recherche dans l’apprentissage automatique.
Cette plateforme permet de faire du traitement de données directement dans le cloud et
d’entraîner des modèles de Machine Learning. Sans avoir besoin d’installer quoi que ce soit sur
votre ordinateur à l’exception d’un navigateur.

II. Jupyter Notebook ?

Jupyter Notebook est une application Web Open Source permettant de créer et de partager des
documents contenant du code (exécutable directement dans le document), des équations, des
images et du texte. Avec cette application il est possible de faire du traitement de données, de la
modélisation statistique, de la visualisation de données, du Machine Learning, etc. Elle est
disponible par défaut dans la distribution Anaconda (Voir https://www.anaconda.com/products/
distribution pour savoir comment l’installer).

Figure 1 : L’interface de jupyter notebook

III. Google Colab, La version cloud de Jupyter Notebook

Pour utiliser Google colab il suffit d’aller sur Google drive ensuite cliquer sur nouveau ensuite sur
« plus » et choisissez « Colaboratory ».

Figure 2 : Google colab via Google drive

Si vous n’avez pas l’option « Colaboratory » cliquez sur « Associer plus d’applications » puis
rechercher « Colaboratory » et cliquez sur connecter. Vous pouvez aussi accéder directement à
l’interface de google colab via le lien suivant : https://colab.research.google.com/ . La fenêtre se
présentera comme suit:
LSI2 / TP’s Techniques d’indexation et recherche multimédias AU. 2021-22

Figure 3 : L’interface de google colab

Comment Manipuler les fichiers ?

• Pour importer des fichiers depuis votre ordinateur
files.upload renvoie un dictionnaire des fichiers qui ont été importés.
La clé du dictionnaire est le nom du fichier importé, la valeur correspond aux données des
fichiers importés.
1 from google.colab import files
2 uploaded = files.upload()
3 for fn in uploaded.keys():
4 print('Vous avez importé le fichier "{name}" qui a une taille de {length} bytes'.format(name=fn,
length=len(uploaded[fn])))
• Pour télécharger des fichiers sur votre ordinateur
files.download fait une requête à votre navigateur pour qu’il télécharge un fichier.
Exemple :
1 from google.colab import files
2 with open('example.txt', 'w') as f:
3 f.write('exemple de contenu')
4 files.download('example.txt'))
• Utiliser les fichiers depuis google drive
1 from google.colab import drive
2 drive.mount('/content/gdrive')
Exécutez la commande ci-dessus et suivez-les instructions afin de connecter votre google drive à
votre noteboook.
Ensuite vous pouvez voir vos fichiers dans google colab avec :
1 !ls "/content/gdrive/My Drive/"
Pour ajouter des fichiers directement sur votre drive il faut :
1 with open('/content/gdrive/My Drive/example.txt', 'w') as f:
2 f.write('Test fichier Google Drive!')
3 #on vérifie ensuite si le fichier est bien créé
4 !cat /content/gdrive/My\ Drive/example.txt
Importer les librairies
L’import des librairies se fait de la même manière que sur un jupyter notebook.
1 import pandas as pd
Cependant si une librairie ne semble pas être installée sur votre environnement google colab, il
vous suffit de l’installer avec !pip install ou !apt-get install. Par exemple :
1 !pip install -q matplotlib-venn
1 !apt-get -qq install -y libfluidsynth1

2
LSI2 / TP’s Techniques d’indexation et recherche multimédias AU. 2021-22

IV. Tokenisation et indexation

Le but de ce TP est d'écrire en Python un programme qui découpe un texte en tokens à l'aide
d'expressions rationnelles. On devrait prendre un texte en français de notre choix (sur le web par
exemple) et de travailler en encodage UTF-8. On doit aussi utiliser les librairies codecs et nltk de
Python pour ouvrir le fichier texte, et afficher tous ses tokens.
Dans un premier temps, on vous demande d’implémenter l’exercice suivant :

Exercice :
Voici quelques documents textuels.

A: Le loup est dans la bergerie.

B: Les moutons sont dans la bergerie.

C: Un loup a mangé un mouton, les autres loups sont restés dans la bergerie.

D: Il y a trois moutons dans le pré, et un mouton dans la gueule du loup.
Prenons le vocabulaire suivant : {« loup », « mouton », « bergerie », « pré », « gueule »}.
1. Donnez, pour chaque document, le tf de chaque terme.
2. Donnez les idf des termes (ne pas prendre le logarithme, pour simplifier).
3. En déduire la matrice d’incidence montrant l’idf pour chaque terme, le nombre de termes
pour chaque document, et le tf pour chaque cellule.

Solution
// *Installation des packages et libraries *
!pip install spacy
!python -m spacy download fr_core_news_sm
import spacy
import fr_core_news_sm
nlp=fr_core_news_sm.load()
// Creation des documents
A = "Le loup est dans la bergerie"
B = "Les moutons sont dans la bergerie"
C = "Un loup a mangé un mouton et les autres loups sont restés dans la bergerie"
D = "il y a trois moutons dans le pré, et un mouton dans la gueule du loup"
// TOKENISATION
def token(doc):
d = nlp(doc)
return [X.text for X in d]

A = token(A)
B = token(B)
C = token(C)
D = token(D)
print(A)
print(B)
print(C)
print(D)
// Normalisation textuelle ( ponctuation et casse)
A=[word.lower() for word in A if word.isalpha() ]
B=[word.lower() for word in B if word.isalpha()]
C=[word.lower() for word in C if word.isalpha()]

3
LSI2 / TP’s Techniques d’indexation et recherche multimédias AU. 2021-22

D=[word.lower() for word in D if word.isalpha()]

print(A)
print(B)
print(C)
print(D)
// Enlever les STOPWORDS
import nltk
nltk.download('stopwords')
from nltk.corpus import stopwords
stopWords = set(stopwords.words('french'))
// [nltk_data] Downloading package stopwords to /root/nltk_data...
//[nltk_data] Unzipping corpora/stopwords.zip.
def enlever_stopwords(words):
clean_words = []
for token in words:
if token not in stopWords and token not in ['a','ai','as','avons','avez','ont']:
clean_words.append(token)
return clean_words

A = enlever_stopwords(A)
B = enlever_stopwords(B)
C = enlever_stopwords(C)
D = enlever_stopwords(D)
print(A)
print(B)
print(C)
print(D)
//STEMMATION
from nltk.stem.snowball import SnowballStemmer
stemmer = SnowballStemmer(language='french')

def return_stem(sentence):
return [stemmer.stem(X) for X in sentence]
A = return_stem(A)
B = return_stem(B)
C = return_stem(C)
D = return_stem(D)

print(A)
print(B)
print(C)
print(D)
//Term frequency d'un mot donné (TF)
from collections import Counter
def term_frequency(document, mot):
stemmot = stemmer.stem(mot)
word_freq = Counter(document)
for word,freq in word_freq.items():
if(word == stemmot):
print('Occurence: ',freq)

def tf(mot):

4
LSI2 / TP’s Techniques d’indexation et recherche multimédias AU. 2021-22

print('mot :',mot)
print('-------------------------')
print('Document A')
term_frequency(A,mot)
print('-------------------------')
print('Document B')
term_frequency(B,mot)
print('-------------------------')
print('Document C')
term_frequency(C,mot)
print('-------------------------')
print('Document D')
term_frequency(D,mot)
//Quelques exemples:
tf('loup')
tf('bergerie')
tf('mouton')
//IDF d'un mot donné
import math

documents =[]
documents.append(A)
documents.append(B)
documents.append(C)
documents.append(D)

def idf(mot):
stemmot = stemmer.stem(mot)
common_list=[]
i =0
for document in documents:
common_list.append(Counter(document))
for common in common_list:
for word,freq in common.items():
if(word == stemmot):
i= i+1
if i == 0:
return "mot n'existe pas dans le corpus"
else:
return math.log(len(documents)/i)
//Quelques exemple:
idf('pré')
idf('loup')
//Matrice d’incidence
import pandas as pd

words = set(A).union(set(B) ).union(set(C) ).union(set(D) )

numOfWordsA = dict.fromkeys(words, 0)
for word in A:
numOfWordsA[word] += 1
numOfWordsB = dict.fromkeys(words, 0)

5
LSI2 / TP’s Techniques d’indexation et recherche multimédias AU. 2021-22

for word in B:
numOfWordsB[word] += 1
numOfWordsC = dict.fromkeys(words, 0)
for word in C:
numOfWordsC[word] += 1
numOfWordsD = dict.fromkeys(words, 0)
for word in D:
numOfWordsD[word] += 1

def matrice(wordDict, bagOfWords):

tfDict = {}
bagOfWordsCount = len(bagOfWords)
for word, count in wordDict.items():
tfDict[word] = count
return tfDict

tfA = matrice(numOfWordsA, A)
tfB = matrice(numOfWordsB, B)
tfC = matrice(numOfWordsC, C)
tfD = matrice(numOfWordsD, D)
tfglobal = pd.DataFrame([tfA, tfB,tfC, tfD ],index=['A','B','C','D'])
tfglobal