Comparaison de modèles, apprentissage des LPC et vraisemblance

1. Importez le module pyagrum dans votre environnement Python.

   import pyAgrum as gum # La librairie pyAgrum
   
   # Vérification des versions
   {
       "pyagrum": gum.__version__, 
   }
   

   pyagrum

   :

   1.12.1

2. Construire la structure du modèle 1.

   # Création du RB   
   bn1 = gum.BayesNet("Vente livret")
   
   # Création de la variable Vente
   va_V = gum.LabelizedVariable("Vente_livret_A", "Vente livret", 2)
   va_V.changeLabel(0, "echec")
   va_V.changeLabel(1, "succes")
   
   # Création de la variable Âge
   va_A = gum.LabelizedVariable("Age", "Âge", 3)
   va_A.changeLabel(0, "c18_25")
   va_A.changeLabel(1, "c26_59")
   va_A.changeLabel(2, "c60")
   
   # Création de la variable Épargne
   va_E = gum.LabelizedVariable("Epargne", "Épargne", 2)
   va_E.changeLabel(0, "non")
   va_E.changeLabel(1, "oui")
   
   # TODO : ajout des variable dans le RB (méthode .add)
   
   # TODO : ajout des arcs (méthode .addArc)
   
   

   # SOLUTION
   # --------
   # Ajout des variables dans le RB
   bn1.add(va_V)
   bn1.add(va_A)
   bn1.add(va_E)
   
   # Ajout des arcs
   bn1.addArc("Age", "Vente_livret_A")
   bn1.addArc("Epargne", "Vente_livret_A")
   

3. Téléchargez le fichier de données vente_livret_A_donnees_10000.csv et lisez ces données dans un DataFrame Pandas avec la fonction read_csv.

   # Lecture des données
   import pandas as pd
   
   data_df = pd.read_csv("vente_livret_A_donnees_10000.csv")
   

4. Utilisez la classe gum.BNLearner et en particulier la méthode fitParameters pour réaliser l'apprentissage des LPC de votre modèle.

   learner = gum.BNLearner(data_df)
   
   learner.fitParameters(bn1)
   
   print(bn1.cpt("Vente_livret_A"))
   print(bn1.cpt("Age"))
   print(bn1.cpt("Epargne"))
   

5. Créez une fonction loglikelihood prenant en entrées un RB et un DataFrame représentant les mêmes variables et retournant la vraisemblance du RB par rapport au données. Il vous faudra utiliser un moteur d'inférence (ex: gum.LazyPropagation) et ses méthodes .setEvidence et .evidenceProbability.

   import math # Pour utiliser math.log
   
   def loglikelihood(bn, data_df):
   
       # TODO: Code à écrire ;)
    
       return loglike
   

   # SOLUTION
   # --------
   import math # Pour utiliser math.log
   
   def loglikelihood(bn, data_df):
   
       loglike = 0
       
       # Création d'un moteur d'inférence
       inf_engine = gum.LazyPropagation(bn)
   
       for idx, obs in data_df.iterrows():
           # Projection de la données courante dans le RB
           inf_engine.setEvidence(obs.to_dict())
           # Calcul de la probabilité (vraisemblance) de la données dans le RB
           data_loglike = inf_engine.evidenceProbability()
           # Passage au log pour obtenir la log-vraisemblance de la données
           # et somme pour calculer la vraisemblance sur toutes les données
           loglike += math.log(data_loglike)
    
       return loglike
   

6. Utilisez votre fonction pour calculer la vraisemble du modèle 1 par rapport aux données.

   loglike = loglikelihood(bn1, data_df)
   print(loglike)
   

   -22879.905249672032
   

Reprendre les étapes précédentes sur les modèles suivants :

• Modèle 2 : \(A \leftarrow V \rightarrow E\).
• Modèle 3 : \(A \leftarrow V \rightarrow E\) et \(A \rightarrow E\).
• Modèle 4 : \(A \leftarrow V \rightarrow E\) et \(A \leftarrow E\).
• Modèle 5 : \(A\), \(V\), \(E\) indépendantes.
  

Comparer les log-vraisemblance obtenues et expliquer les résultats.

# SOLUTION
# --------
# Spécification des structures de chaque modèle
bn_struct_specs = {
    "M1": [("Age", "Vente_livret_A"), ("Epargne", "Vente_livret_A")],
    "M2": [("Vente_livret_A", "Age"), ("Vente_livret_A", "Epargne")],
    "M3": [("Vente_livret_A", "Age"), ("Vente_livret_A", "Epargne"), ("Age", "Epargne")],
    "M4": [("Vente_livret_A", "Age"), ("Vente_livret_A", "Epargne"), ("Epargne", "Age")],
    "M5": [],
}

# Boucle de construction de chaque modèle
bn_models = {}
for bn_name, struct in bn_struct_specs.items():
    # Construction du RB courant
    bn = gum.BayesNet(bn_name)
    bn.add(va_V)
    bn.add(va_A)
    bn.add(va_E)
    [bn.addArc(*arc) for arc in struct]

    # Apprentissage des LPC
    learner.fitParameters(bn)
    
    bn_models[bn_name] = bn

# Boucle de calcul des vraisemblances de chaque modèle
bn_loglike = {}
for bn_name, bn in bn_models.items():
    bn_loglike[bn_name] = loglikelihood(bn, data_df)

print(bn_loglike)

{'M1': -22879.905249672032, 'M2': -23296.642978057353, 'M3': -21958.960794571823, 'M4': -21958.960794571823, 'M5': -24196.13497634752}