TP Modèle de recherche vectoriel

Développer un modèle vectoriel sur la base de la représentation VSM. Nous ne réaliserons pas d'évaluation cette année.

Pour le traitement des requêtes, vous pouvez vous référer au transparent 12 du cours. On va traiter la requête en calculant la correspondance RSV par un calcul de cosinus. Ce cosinus est égal au produit scalaire des vecteur d et q divisé par le produit des normes de d et de q. Vous avez déjà stocké tout ce qu'il nous faut dasn les séances précédentes : le fichier outil pour analyser les requêtes, le vocabulaire avec les idf pour créer les vecteurs requêtes, l'index pour calculer les correspondances, les normes des documents dans le TP précédent. Comme nous l'aons vu en cours, fait d'utiliser l'index inversé permet de calculer très rapidement le produit scalaire, en se focalisant sur les dimensions pour lesquelles d et q sont non-nulles en même temps.

On va utiliser la représentation du vocabulaire vu aux TPs précédents, et permettre de traiter une requête fournie en direct.

Le programme de traitement des requêtes ne doit pas relancer la création du vocabulaire, de l'index ou des normes des vecteurs documents.

Votre programme va :

1. Charger l'index inversé
2. Charger le vocabulaire
3. Charger les normes des documents
4. Charger le fichier des mots outils
5. Boucle tant que requête non vide
   1. Acquérir une requête q (tapée à la main)
   2. Transformer q en un vecteur vq (encore un dictionnaire) avec pondération tf.idf, et calculer la norme de la requête q (= sqrt(somme(carré)) ) : ces traitements sont les mêmes que lors de la création du vecteur pour les documents. NOTE 1 : le “tf” est le ptf = nombre d'occurrence du mot dans la requête. NOTE 2 : l'“idf” est le pdf qui est stocké dans le vocabulaire (partie indexation).
   3. Traiter la requête en utilisant uniquement les lignes dans l'index inversé correspondant aux termes de la requête. a) on calcule, grâce à l'index inversé, le produit scalaire entre requête et document (pour cela on stocke les calculs intermédiaires dans un dictionnaire python, res, qui a la même structure qu'une ligne de l'index inversé, et qui contient des couples (doc,score)); et b) on divise ces scores par “la norme de d * la norme de q” (on modifie les valeurs du dictionnaire res)
   4. Trier les réponses par ordre de pertinence décroissante. A LIRE : détail des parties III et IV ici.
   5. Afficher les n (constante) premiers documents les plus pertinents la réponse.

Le coeur de votre travail va donc ici être d'écrire une fonction regroupant le point 4 ci-dessus, et qui retourne les k documents les plus similaires à une requête donnée par la mesure de similarité cosine, où k est un paramètre d'entrée de la fonction.

NOTES : 1. Votre code doit être robuste aux erreurs (par exemple ne pas planter si un terme de la requête n'est pas dans le vocabulaire). 2. Votre code doit donner exactement le même résultat avec le requête “computer” et “computer computer”. 3. Si il y a moins de k documents qui répondent, votre programme ne doit pas planter.

Infos additionnelles pour l'utilisation de l'index inversé A LIRE.

 Exemple: Pour la requête "a1" le résultat (sans arrondi, et avec les noms de fichiers initiaux, 10 premiers résultats) est :
1 .  CACM-1539   0.7360533125872257
2 .  CACM-1218   0.5370128320439512
3 .  CACM-1840   0.48823786194521684
4 .  CACM-1219   0.48488589645993635
5 .  CACM-2121   0.4815574765638951
6 .  CACM-1538   0.46689746802257087
7 .  CACM-1537   0.46689746802257087
8 .  CACM-2103   0.4651415247593109
9 .  CACM-1557   0.46135116066409054
10 .  CACM-1217   0.45468997397016137

Autre exemple :

 Exemple: Pour la requête "infinity" le résultat (sans arrondi, et avec les noms de fichiers initiaux, 10 premiers résultats) est :
1 .  CACM-1977   0.20791032426181502
2 .  CACM-1638   0.1475147469974677
3 .  CACM-1721   0.12743135017963975
4 .  CACM-2786   0.11337293099881011

... il n'y a que 4 documents qui répondent...

Bonus optionnel : si vous avez terminé tous les éléments précédents vous pouvez choisir d'améliorer le système en :

1. indiquant dans la requête le nombre de réponses attendues (à vous de choisir comment cette information est donnée par l'utilisateur)
2. présentant non pas l'identifiant des documents en réponse, mais aussi par exemple les x premiers mots de chaque document (un peu à la manière des “snippets” Google).
3. indiquant par une échelle (allant par exemple de “++++” pour “très pertinent” à “+” pour “peu pertinent”) qui synthétise la pertinence des documents renvoyés
4. indiquant par un graphique la répartition des valeurs de pertinence des y premiers documents (avec y possiblement différent de n)
5. proposer un moyen de modifier la requête que l'on vient de poser
6. ou tout autre évolution de votre choix

Vous devez écrire un rapport sur l'ensemble de vos travaux durant les 5 séances de TP (génération des vecteurs documents, de l'index inversé, recherche). Vous devez m'indiquer grossièrement les choix faits, et des extraits des résultats de chaque programme en fonction des entrées. Vous devez générer un fichier zip quoi contient l'ensemble de vos codes python écrits (et commentés), avec un README qui décrit un une phrase vos programmes et qui indique leur usage.

Vous devez m'envoyer par mail, réception avant le 10 avril 2024 à 23h59, le pdf et le zip à Philippe.Mulhem@imag.fr avec le titre : “[INFO4-TP-ARI] Nom1 Nom2” avec vos noms si vous être 2 auteurs, et “[INFO4-TP-ARI] Nom” avec votre nom si vous êtes un seul auteur.

Contenu du rapport :

1. Votre code commenté
2. Un document écrit qui 1) décrit rapidement vos programmes ; 2) utilise des exemples pour comparer des valeurs calculés à la main (par exemple montrer le cas de l'idf pour codeword, le cas où on pose une requête “codeword” en montrant par exemple le résultat à la main entre cette requête et le document CACM-2834, etc.).

Pour afficher les éléments d'un dictionnaire dans un ordre donné (ici ordre décroissant), on peut utilisé la fonction itemgetter de la librairie operator de Python, de la manièere suivante sur une variable resultat_partiel qui est un dictionnaire qui contient en clé l'identifiant de document et en valeur de cosinus calculé :

import operator
from operator import itemgetter
...
# affiche les 10 premiers resultats de resultat_partiel (dictionnaire [ "id de doc" : score de cosinus]), trié par ordre décroissant sur les valeurs de cosinus (récupérées par itemgetter(1))
nb=0
    for key, value in reversed(sorted(resultat_partiel.items(), key = itemgetter(1))):
        print (nb+1,". ",key," ",value)
        nb += 1
        if nb >= 10:
            break