tef-innu

rapport (4229B)

---

 #!/usr/bin/env python3
 #
 # rapport.py -- Produire un rapport sur la performance du modèle.
 #
 # $1 - Chemin vers l’extension
 # $2 - Chemin vers l’échantillon
 # $3 - Chemin vers les préfixes
 
 import sys
 
 # Charger dans un ensemble de tuples les paires contenues dans un fichier. Ces
 # paires doivent figurer une par ligne et leurs éléments doivent être séparés
 # par un caractère de tabulation.
 def charger_paires(fichier):
     paires = set()
     with open(fichier, "r") as f:
         for ligne in f:
             champs = ligne.rstrip().split("\t")
             if len(champs) != 2:
                 raise ValueError(f"{fichier}: {len(champs)} champ(s) plutôt que 2.")
             paires.add((champs[0], champs[1]))
     return paires
 
 def charger_lignes(fichier):
     lignes = set()
     with open(fichier, "r") as f:
         lignes = {ligne.rstrip() for ligne in f}
     return lignes
 
 # Convertir les paires d’un ensembe de couples à un dictionnaire dont la clé en
 # est le premier élément et la valeur le second. Aucune information n’est
 # perdue si le transducteur est séquentiel.
 def paires_vers_dict(paires):
     return {paire[0]:paire[1] for paire in paires}
 
 # Tester la séquentialité de l’extension dans le sens de la génération. Une
 # description abstraite doit correspondre à une seule forme. Renvoie un
 # ensemble contenant les descriptions abstraites qui rendent l’extension
 # non-séquentielle.
 def tester_sequentialite(extension):
     desc = set()
     doublons = set()
     for paire in extension:
         if paire[0] not in desc:
             desc.add(paire[0])
         else:
             doublons.add(paire[0])
     return doublons
 
 # Renvoyer les formes générés correctes.
 def vrais_positifs(echantillon, extension):
     vp = set()
     for c in echantillon:
         if c in extension and echantillon[c] == extension[c]:
             vp.add(c)
     return vp
 
 # Renvoyer les formes générées incorrectes.
 def faux_positifs(echantillon, extension):
     fp = set()
     for c in echantillon:
         if c in extension and echantillon[c] != extension[c]:
             fp.add(c)
     return fp
 
 # Renvoyer les formes non générées qui auraient dû l’être.
 def faux_negatifs(echantillon, extension):
     fn = set()
     for c in echantillon:
         if c not in extension:
             fn.add(c)
     return fn
 
 def precision(vp, fp):
     return len(vp) / (len(vp) + len(fp)) * 100
 
 def rappel(vp, fn):
     return len(vp) / (len(vp) + len(fn)) * 100
 
 def f1(pre, rap):
     return 2 * (pre * rap) / (pre + rap)
 
 # Afficher le rapport un sortie standard.
 def rapporter (echantillon, extension):
     print("=== RAPPORT ===")
     print()
     res = tester_sequentialite(extension)
     if res:
         print("NON SÉQUENTIEL!")
         for desc in res:
             print(desc)
         return
     # Convertir les paires
     echantillon = paires_vers_dict(echantillon)
     extension = paires_vers_dict(extension)
     print(f"Nombre de formes générées: {len(extension)}")
     res = len({extension[c] for c in extension})
     print("Nombre de formes uniques générées: "
         f"{res} ({res/len(extension)*100:.2f}%)")
     print(f"Taille de l’échantillon: {len(echantillon)} "
           f"({len(echantillon)/len(extension)*100:.2f}%)")
     print()
     vp = vrais_positifs(echantillon, extension)
     fp = faux_positifs(echantillon, extension)
     fn = faux_negatifs(echantillon, extension)
     print("--- FAUX POSITIFS ---")
     print()
     for f in fp:
         print(f"{f}: {echantillon[f]} ({extension[f]})")
     if fp:
         print()
     print("--- FAUX NÉGATIFS ---")
     print()
     for f in fn:
         print(f"{f}: {echantillon[f]}")
     if fn:
         print()
     print(f"Nombre de vrais positifs: {len(vp)}")
     print(f"Nombre de faux positifs: {len(fp)}")
     print(f"Nombre de faux négatifs: {len(fn)}")
     pre = precision(vp, fp)
     print(f"Précision: {pre:.2f}")
     rap = rappel(vp, fn)
     print(f"Rappel: {rap:.2f}")
     f = f1(pre, rap)
     print(f"F1: {f:.2f}")
 
 if __name__ == "__main__":
     if len(sys.argv) != 3:
         raise RuntimeError("Mauvais arguments.")
 
     ext = charger_paires(sys.argv[1])
     ech = charger_paires(sys.argv[2])
 
     rapporter(ech, ext)