Tracé d'ellipses de confiance | Tutoriel Python Matplotlib

Introduction

Ce laboratoire démontrera comment tracer des ellipses de confiance pour un ensemble de données bidimensionnelles à l'aide de Python Matplotlib. Une ellipse de confiance est une représentation graphique de la covariance d'un ensemble de données, montrant l'incertitude de la moyenne estimée et de l'écart-type. Les ellipses sont tracées à l'aide du coefficient de corrélation de Pearson.

Conseils pour la machine virtuelle (VM)

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

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

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

Importation des bibliothèques requises

La première étape consiste à importer les bibliothèques nécessaires. Pour ce laboratoire, nous aurons besoin de numpy et de matplotlib.pyplot.

import matplotlib.pyplot as plt
import numpy as np

Définition de la fonction `confidence_ellipse`

Ensuite, nous définissons la fonction confidence_ellipse qui prendra en entrée les coordonnées x et y de l'ensemble de données, l'objet d'axes (axes object) dans lequel tracer l'ellipse et le nombre d'écarts-types. Elle renvoie un objet patch de Matplotlib représentant l'ellipse.

def confidence_ellipse(x, y, ax, n_std=3.0, facecolor='none', **kwargs):
    """
    Crée un graphique de l'ellipse de confiance de covariance de *x* et *y*.

    Paramètres
    ----------
    x, y : semblable à un tableau, forme (n, )
        Données d'entrée.

    ax : matplotlib.axes.Axes
        L'objet d'axes dans lequel tracer l'ellipse.

    n_std : flottant
        Le nombre d'écarts-types pour déterminer les rayons de l'ellipse.

    **kwargs
        Transmis à `~matplotlib.patches.Ellipse`

    Retours
    -------
    matplotlib.patches.Ellipse
    """
    if x.size!= y.size:
        raise ValueError("x et y doivent avoir la même taille")

    cov = np.cov(x, y)
    pearson = cov[0, 1]/np.sqrt(cov[0, 0] * cov[1, 1])
    ## Utilisation d'un cas particulier pour obtenir les valeurs propres de cet
    ## ensemble de données bidimensionnel.
    ell_radius_x = np.sqrt(1 + pearson)
    ell_radius_y = np.sqrt(1 - pearson)
    ellipse = Ellipse((0, 0), width=ell_radius_x * 2, height=ell_radius_y * 2,
                      facecolor=facecolor, **kwargs)

    ## Calcul de l'écart-type de x à partir
    ## de la racine carrée de la variance et multiplication
    ## par le nombre donné d'écarts-types.
    scale_x = np.sqrt(cov[0, 0]) * n_std
    mean_x = np.mean(x)

    ## calcul de l'écart-type de y...
    scale_y = np.sqrt(cov[1, 1]) * n_std
    mean_y = np.mean(y)

    transf = transforms.Affine2D() \
       .rotate_deg(45) \
       .scale(scale_x, scale_y) \
       .translate(mean_x, mean_y)

    ellipse.set_transform(transf + ax.transData)
    return ax.add_patch(ellipse)

Définition de la fonction `get_correlated_dataset`

Nous avons également besoin d'une fonction pour générer un ensemble de données bidimensionnelles avec une moyenne, des dimensions et une corrélation spécifiées.

def get_correlated_dataset(n, dependency, mu, scale):
    """
    Crée un ensemble de données bidimensionnelles aléatoires avec la moyenne bidimensionnelle (mu) et les dimensions (scale) spécifiées.
    La corrélation peut être contrôlée par le paramètre 'dependency', une matrice 2x2.
    """
    latent = np.random.randn(n, 2)
    dependent = latent.dot(dependency)
    scaled = dependent * scale
    scaled_with_offset = scaled + mu
    ## retourne x et y du nouvel ensemble de données corrélé
    return scaled_with_offset[:, 0], scaled_with_offset[:, 1]

Tracé des corrélations positives, négatives et faibles

Maintenant, nous pouvons utiliser ces fonctions pour tracer les ellipses de confiance d'ensembles de données avec des corrélations positives, négatives et faibles.

np.random.seed(0)

PARAMETERS = {
    'Positive correlation': [[0.85, 0.35],
                             [0.15, -0.65]],
    'Negative correlation': [[0.9, -0.4],
                             [0.1, -0.6]],
    'Weak correlation': [[1, 0],
                         [0, 1]],
}

mu = 2, 4
scale = 3, 5

fig, axs = plt.subplots(1, 3, figsize=(9, 3))
for ax, (title, dependency) in zip(axs, PARAMETERS.items()):
    x, y = get_correlated_dataset(800, dependency, mu, scale)
    ax.scatter(x, y, s=0.5)

    ax.axvline(c='grey', lw=1)
    ax.axhline(c='grey', lw=1)

    confidence_ellipse(x, y, ax, edgecolor='red')

    ax.scatter(mu[0], mu[1], c='red', s=3)
    ax.set_title(title)

plt.show()

Tracé de différentes valeurs d'écart-type

Nous pouvons également tracer les ellipses de confiance avec différents nombres d'écarts-types.

fig, ax_nstd = plt.subplots(figsize=(6, 6))

dependency_nstd = [[0.8, 0.75],
                   [-0.2, 0.35]]
mu = 0, 0
scale = 8, 5

ax_nstd.axvline(c='grey', lw=1)
ax_nstd.axhline(c='grey', lw=1)

x, y = get_correlated_dataset(500, dependency_nstd, mu, scale)
ax_nstd.scatter(x, y, s=0.5)

confidence_ellipse(x, y, ax_nstd, n_std=1,
                   label=r'$1\sigma$', edgecolor='firebrick')
confidence_ellipse(x, y, ax_nstd, n_std=2,
                   label=r'$2\sigma$', edgecolor='fuchsia', linestyle='--')
confidence_ellipse(x, y, ax_nstd, n_std=3,
                   label=r'$3\sigma$', edgecolor='blue', linestyle=':')

ax_nstd.scatter(mu[0], mu[1], c='red', s=3)
ax_nstd.set_title('Different standard deviations')
ax_nstd.legend()
plt.show()

Utilisation d'arguments clé-valeur

Enfin, nous pouvons personnaliser l'apparence des ellipses en utilisant des arguments clé-valeur (keyword arguments).

fig, ax_kwargs = plt.subplots(figsize=(6, 6))
dependency_kwargs = [[-0.8, 0.5],
                     [-0.2, 0.5]]
mu = 2, -3
scale = 6, 5

ax_kwargs.axvline(c='grey', lw=1)
ax_kwargs.axhline(c='grey', lw=1)

x, y = get_correlated_dataset(500, dependency_kwargs, mu, scale)
## Trace l'ellipse avec zorder=0 afin de démontrer
## sa transparence (causée par l'utilisation de alpha).
confidence_ellipse(x, y, ax_kwargs,
                   alpha=0.5, facecolor='pink', edgecolor='purple', zorder=0)

ax_kwargs.scatter(x, y, s=0.5)
ax_kwargs.scatter(mu[0], mu[1], c='red', s=3)
ax_kwargs.set_title('Using keyword arguments')

fig.subplots_adjust(hspace=0.25)
plt.show()

Résumé

Dans ce laboratoire (lab), nous avons appris à tracer des ellipses de confiance pour un ensemble de données bidimensionnelles en utilisant Python et Matplotlib. Nous avons défini les fonctions confidence_ellipse et get_correlated_dataset, et les avons utilisées pour tracer des ellipses pour des ensembles de données avec différentes corrélations et nombres d'écarts-types. Nous avons également montré comment personnaliser l'apparence des ellipses en utilisant des arguments clé-valeur (keyword arguments).

Tracé d'ellipses de confiance avec Matplotlib