Mise à jour bayésienne avec Matplotlib

Introduction

La mise à jour bayésienne est une approche statistique qui nous permet de mettre à jour la probabilité d'une hypothèse à mesure que de nouvelles données deviennent disponibles. Dans ce laboratoire, nous utiliserons Matplotlib pour créer une animation qui montre comment fonctionne la mise à jour bayésienne. Plus précisément, nous allons simuler une expérience de lancer de pièce et utiliser la mise à jour bayésienne pour estimer la probabilité que la pièce tombe face.

Conseils sur la machine virtuelle

Une fois le démarrage de la machine virtuelle terminé, cliquez dans le coin supérieur gauche pour basculer vers l'onglet Carnet de notes pour accéder au carnet Jupyter pour pratiquer.

Parfois, vous devrez peut-être attendre quelques secondes pour que le carnet Jupyter ait fini de charger. La validation des opérations ne peut pas être automatisée en raison des limitations du carnet Jupyter.

Si vous rencontrez des problèmes pendant l'apprentissage, n'hésitez pas à demander à Labby. Donnez votre feedback après la session, et nous résoudrons rapidement le problème pour vous.

Importation des bibliothèques requises

Nous commençons par importer les bibliothèques que nous utiliserons dans le laboratoire. Plus précisément, nous utiliserons matplotlib.pyplot pour la visualisation, numpy pour les calculs numériques et math pour les fonctions mathématiques.

import math

import matplotlib.pyplot as plt
import numpy as np

Définir la fonction de densité de probabilité (PDF) de la distribution bêta

La distribution bêta est une distribution de probabilité continue qui est souvent utilisée pour représenter la distribution des probabilités. Dans la mise à jour bayésienne, nous utilisons la distribution bêta comme distribution a priori pour représenter nos croyances sur la probabilité d'une hypothèse avant d'observer toute donnée. Nous mettons ensuite à jour la distribution bêta à mesure que nous observons de nouvelles données.

Pour simuler la mise à jour bayésienne, nous devons définir une fonction qui calcule la fonction de densité de probabilité (PDF) de la distribution bêta. Nous pouvons utiliser la fonction math.gamma pour calculer la fonction gamma, qui est utilisée dans la PDF de la distribution bêta.

def beta_pdf(x, a, b):
    return (x**(a-1) * (1-x)**(b-1) * math.gamma(a + b)
            / (math.gamma(a) * math.gamma(b)))

Définir la classe UpdateDist

Ensuite, nous définissons une classe appelée UpdateDist qui sera utilisée pour mettre à jour la distribution bêta à mesure que de nouvelles données sont observées. La classe UpdateDist prend deux arguments : l'objet axe Matplotlib et la probabilité initiale de succès.

class UpdateDist:
    def __init__(self, ax, prob=0.5):
        self.success = 0
        self.prob = prob
        self.line, = ax.plot([], [], 'k-')
        self.x = np.linspace(0, 1, 200)
        self.ax = ax

        ## Configure les paramètres du tracé
        self.ax.set_xlim(0, 1)
        self.ax.set_ylim(0, 10)
        self.ax.grid(True)

        ## Cette ligne verticale représente la valeur théorique vers laquelle
        ## la distribution tracée devrait converger.
        self.ax.axvline(prob, linestyle='--', color='black')

La méthode __init__ initialise l'instance de la classe en définissant le nombre initial de succès à zéro (self.success = 0) et la probabilité initiale de succès à la valeur passée en argument (self.prob = prob). Nous créons également un objet de ligne pour représenter la distribution bêta et configurons les paramètres du tracé.

La méthode __call__ est appelée chaque fois que l'animation est mise à jour. Elle simule une expérience de lancer de pièce et met à jour la distribution bêta en conséquence.

def __call__(self, i):
        ## De cette manière, le tracé peut continuer à s'exécuter et nous
        ## continuons simplement à observer de nouvelles réalités du processus
        if i == 0:
            self.success = 0
            self.line.set_data([], [])
            return self.line,

        ## Choisissez le succès en fonction de la dépassement d'un seuil avec un tirage uniforme
        if np.random.rand() < self.prob:
            self.success += 1
        y = beta_pdf(self.x, self.success + 1, (i - self.success) + 1)
        self.line.set_data(self.x, y)
        return self.line,

Si ceci est la première trame de l'animation (if i == 0), nous réinitialisons le nombre de succès à zéro et effaçons l'objet de ligne. Sinon, nous simulons une expérience de lancer de pièce en générant un nombre aléatoire entre 0 et 1 (np.random.rand()) et en le comparant à la probabilité de succès (self.prob). Si le nombre aléatoire est inférieur à la probabilité de succès, nous le comptons comme un succès et mettons à jour la distribution bêta en utilisant la fonction beta_pdf. Enfin, nous mettons à jour l'objet de ligne avec les nouvelles données et le retournons.

Créer une animation

Maintenant que nous avons défini la classe UpdateDist, nous pouvons créer l'animation en utilisant la classe FuncAnimation de Matplotlib. Nous créons un objet figure et un objet axe et passons l'objet axe à la classe UpdateDist pour créer une nouvelle instance de la classe.

fig, ax = plt.subplots()
ud = UpdateDist(ax, prob=0.7)
anim = FuncAnimation(fig, ud, frames=100, interval=100, blit=True)
plt.show()

La classe FuncAnimation prend plusieurs arguments :

• fig : l'objet figure
• ud : l'instance de UpdateDist
• frames : le nombre d'images à animer
• interval : le temps entre les images en millisecondes
• blit : indique si seulement les parties du tracé qui ont changé doivent être mises à jour

Interpréter les résultats

L'animation montre comment la distribution bêta est mise à jour à mesure que de nouvelles données sont observées. La ligne pointillée noire représente la vraie probabilité de succès (c'est-à-dire la probabilité que la pièce tombe face). Au fur et à mesure que l'animation progresse, on voit que la distribution bêta commence avec un pic à la probabilité a priori de succès (0,7) et se déplace progressivement vers la vraie probabilité de succès à mesure qu'on observe plus de données.

Sommaire

Dans ce laboratoire, nous avons utilisé Matplotlib pour créer une animation qui démontre la mise à jour bayésienne. Nous avons défini une fonction pour calculer la fonction de densité de probabilité (PDF) de la distribution bêta et une classe pour mettre à jour la distribution bêta à mesure que de nouvelles données sont observées. Nous avons ensuite utilisé la classe FuncAnimation de Matplotlib pour créer l'animation et interpréter les résultats.